code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/graphics/chromium/cc/CCMainThreadTask.h

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1.  Redistributions of source code must retain the above copyright
   8  *     notice, this list of conditions and the following disclaimer.
   9  * 2.  Redistributions in binary form must reproduce the above copyright
  10  *     notice, this list of conditions and the following disclaimer in the
  11  *     documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24 #ifndef CCMainThreadTask_h
  25 #define CCMainThreadTask_h
  26
  27 #include "CrossThreadCopier.h"
  28 #include "CrossThreadTask.h"
  29 #include "cc/CCMainThread.h"
  30 #include <wtf/PassOwnPtr.h>
  31 #include <wtf/PassRefPtr.h>
  32
  33 namespace WebCore {
  34
  35 template<typename T>
  36 class MainThreadTask0 : public CCMainThread::Task {
  37 public:
  38     typedef void (T::*Method)();
  39     typedef MainThreadTask0<T> MainThreadTaskImpl;
  40
  41     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method)
  42     {
  43         return adoptPtr(new MainThreadTaskImpl(instance, method));
  44     }
  45
  46 private:
  47     MainThreadTask0(T* instance, Method method)
  48         : CCMainThread::Task(instance)
  49         , m_method(method)
  50     {
  51     }
  52
  53     virtual void performTask()
  54     {
  55         (*static_cast<T*>(instance()).*m_method)();
  56     }
  57
  58 private:
  59     Method m_method;
  60 };
  61
  62 template<typename T, typename P1, typename MP1>
  63 class MainThreadTask1 : public CCMainThread::Task {
  64 public:
  65     typedef void (T::*Method)(MP1);
  66     typedef MainThreadTask1<T, P1, MP1> MainThreadTaskImpl;
  67     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
  68
  69     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method, Param1 parameter1)
  70     {
  71         return adoptPtr(new MainThreadTaskImpl(instance, method, parameter1));
  72     }
  73
  74 private:
  75     MainThreadTask1(T* instance, Method method, Param1 parameter1)
  76         : CCMainThread::Task(instance)
  77         , m_method(method)
  78         , m_parameter1(parameter1)
  79     {
  80     }
  81
  82     virtual void performTask()
  83     {
  84         (*static_cast<T*>(instance()).*m_method)(m_parameter1);
  85     }
  86
  87 private:
  88     Method m_method;
  89     P1 m_parameter1;
  90 };
  91
  92 template<typename T, typename P1, typename MP1, typename P2, typename MP2>
  93 class MainThreadTask2 : public CCMainThread::Task {
  94 public:
  95     typedef void (T::*Method)(MP1, MP2);
  96     typedef MainThreadTask2<T, P1, MP1, P2, MP2> MainThreadTaskImpl;
  97     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
  98     typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
  99
 100     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2)
 101     {
 102         return adoptPtr(new MainThreadTaskImpl(instance, method, parameter1, parameter2));
 103     }
 104
 105 private:
 106     MainThreadTask2(T* instance, Method method, Param1 parameter1, Param2 parameter2)
 107         : CCMainThread::Task(instance)
 108         , m_method(method)
 109         , m_parameter1(parameter1)
 110         , m_parameter2(parameter2)
 111     {
 112     }
 113
 114     virtual void performTask()
 115     {
 116         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2);
 117     }
 118
 119 private:
 120     Method m_method;
 121     P1 m_parameter1;
 122     P2 m_parameter2;
 123 };
 124
 125 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 126 class MainThreadTask3 : public CCMainThread::Task {
 127 public:
 128     typedef void (T::*Method)(MP1, MP2, MP3);
 129     typedef MainThreadTask3<T, P1, MP1, P2, MP2, P3, MP3> MainThreadTaskImpl;
 130     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
 131     typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
 132     typedef typename CrossThreadTaskTraits<P3>::ParamType Param3;
 133
 134     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
 135     {
 136         return adoptPtr(new MainThreadTaskImpl(instance, method, parameter1, parameter2, parameter3));
 137     }
 138
 139 private:
 140     MainThreadTask3(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
 141         : CCMainThread::Task(instance)
 142         , m_method(method)
 143         , m_parameter1(parameter1)
 144         , m_parameter2(parameter2)
 145         , m_parameter3(parameter3)
 146     {
 147     }
 148
 149     virtual void performTask()
 150     {
 151         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3);
 152     }
 153
 154 private:
 155     Method m_method;
 156     P1 m_parameter1;
 157     P2 m_parameter2;
 158     P3 m_parameter3;
 159 };
 160
 161
 162 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 163 class MainThreadTask4 : public CCMainThread::Task {
 164 public:
 165     typedef void (T::*Method)(MP1, MP2, MP3, MP4);
 166     typedef MainThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4> MainThreadTaskImpl;
 167     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
 168     typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
 169     typedef typename CrossThreadTaskTraits<P3>::ParamType Param3;
 170     typedef typename CrossThreadTaskTraits<P4>::ParamType Param4;
 171
 172     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
 173     {
 174         return adoptPtr(new MainThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4));
 175     }
 176
 177 private:
 178     MainThreadTask4(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
 179         : CCMainThread::Task(instance)
 180         , m_method(method)
 181         , m_parameter1(parameter1)
 182         , m_parameter2(parameter2)
 183         , m_parameter3(parameter3)
 184         , m_parameter4(parameter4)
 185     {
 186     }
 187
 188     virtual void performTask()
 189     {
 190         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4);
 191     }
 192
 193 private:
 194     Method m_method;
 195     P1 m_parameter1;
 196     P2 m_parameter2;
 197     P3 m_parameter3;
 198     P4 m_parameter4;
 199 };
 200
 201 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 202 class MainThreadTask5 : public CCMainThread::Task {
 203 public:
 204     typedef void (T::*Method)(MP1, MP2, MP3, MP4, MP5);
 205     typedef MainThreadTask5<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5> MainThreadTaskImpl;
 206     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
 207     typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
 208     typedef typename CrossThreadTaskTraits<P3>::ParamType Param3;
 209     typedef typename CrossThreadTaskTraits<P4>::ParamType Param4;
 210     typedef typename CrossThreadTaskTraits<P5>::ParamType Param5;
 211
 212     static PassOwnPtr<MainThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
 213     {
 214         return adoptPtr(new MainThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4, parameter5));
 215     }
 216
 217 private:
 218     MainThreadTask5(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
 219         : CCMainThread::Task(instance)
 220         , m_method(method)
 221         , m_parameter1(parameter1)
 222         , m_parameter2(parameter2)
 223         , m_parameter3(parameter3)
 224         , m_parameter4(parameter4)
 225         , m_parameter5(parameter5)
 226     {
 227     }
 228
 229     virtual void performTask()
 230     {
 231         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5);
 232     }
 233
 234 private:
 235     Method m_method;
 236     P1 m_parameter1;
 237     P2 m_parameter2;
 238     P3 m_parameter3;
 239     P4 m_parameter4;
 240     P5 m_parameter5;
 241 };
 242
 243 template<typename T>
 244 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 245     T* const callee,
 246     void (T::*method)());
 247
 248 template<typename T>
 249 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 250     T* const callee,
 251     void (T::*method)())
 252 {
 253     return MainThreadTask0<T>::create(
 254         callee,
 255         method);
 256 }
 257
 258 template<typename T, typename P1, typename MP1>
 259 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 260     T* const callee,
 261     void (T::*method)(MP1),
 262     const P1& parameter1)
 263 {
 264     return MainThreadTask1<T, typename CrossThreadCopier<P1>::Type, MP1>::create(
 265         callee,
 266         method,
 267         CrossThreadCopier<P1>::copy(parameter1));
 268 }
 269
 270 template<typename T, typename P1, typename MP1, typename P2, typename MP2>
 271 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 272     T* const callee,
 273     void (T::*method)(MP1, MP2),
 274     const P1& parameter1,
 275     const P2& parameter2)
 276 {
 277     return MainThreadTask2<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
 278         callee,
 279         method,
 280         CrossThreadCopier<P1>::copy(parameter1),
 281         CrossThreadCopier<P2>::copy(parameter2));
 282 }
 283
 284 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 285 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 286     T* const callee,
 287     void (T::*method)(MP1, MP2, MP3),
 288     const P1& parameter1,
 289     const P2& parameter2,
 290     const P3& parameter3)
 291 {
 292     return MainThreadTask3<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
 293         callee,
 294         method,
 295         CrossThreadCopier<P1>::copy(parameter1),
 296         CrossThreadCopier<P2>::copy(parameter2),
 297         CrossThreadCopier<P3>::copy(parameter3));
 298 }
 299
 300 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 301 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 302     T* const callee,
 303     void (T::*method)(MP1, MP2, MP3, MP4),
 304     const P1& parameter1,
 305     const P2& parameter2,
 306     const P3& parameter3,
 307     const P4& parameter4)
 308 {
 309     return MainThreadTask4<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3, typename CrossThreadCopier<P4>::Type, MP4>::create(
 310         callee,
 311         method,
 312         CrossThreadCopier<P1>::copy(parameter1),
 313         CrossThreadCopier<P2>::copy(parameter2),
 314         CrossThreadCopier<P3>::copy(parameter3),
 315         CrossThreadCopier<P4>::copy(parameter4));
 316
 317 }
 318
 319 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 320 PassOwnPtr<CCMainThread::Task> createMainThreadTask(
 321     T* const callee,
 322     void (T::*method)(MP1, MP2, MP3, MP4, MP5),
 323     const P1& parameter1,
 324     const P2& parameter2,
 325     const P3& parameter3,
 326     const P4& parameter4,
 327     const P5& parameter5)
 328 {
 329     return MainThreadTask5<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3, typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5>::create(
 330         callee,
 331         method,
 332         CrossThreadCopier<P1>::copy(parameter1),
 333         CrossThreadCopier<P2>::copy(parameter2),
 334         CrossThreadCopier<P3>::copy(parameter3),
 335         CrossThreadCopier<P4>::copy(parameter4),
 336         CrossThreadCopier<P5>::copy(parameter5));
 337
 338 }
 339
 340 } // namespace WebCore
 341
 342 #endif // MainThreadTask_h