cc/CCThreadTask.h

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 #ifndef CCThreadTask_h
   5 #define CCThreadTask_h
   6
   7 #include "CCThread.h"
   8 #include <wtf/PassOwnPtr.h>
   9 #include <wtf/PassRefPtr.h>
  10
  11 namespace WebCore {
  12
  13 template<typename T>
  14 class CCThreadTask0 : public CCThread::Task {
  15 public:
  16     typedef void (T::*Method)();
  17     typedef CCThreadTask0<T> CCThreadTaskImpl;
  18
  19     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method)
  20     {
  21         return adoptPtr(new CCThreadTaskImpl(instance, method));
  22     }
  23
  24 private:
  25     CCThreadTask0(T* instance, Method method)
  26         : CCThread::Task(instance)
  27         , m_method(method)
  28     {
  29     }
  30
  31     virtual void performTask() OVERRIDE
  32     {
  33         (*static_cast<T*>(instance()).*m_method)();
  34     }
  35
  36 private:
  37     Method m_method;
  38 };
  39
  40 template<typename T, typename P1, typename MP1>
  41 class CCThreadTask1 : public CCThread::Task {
  42 public:
  43     typedef void (T::*Method)(MP1);
  44     typedef CCThreadTask1<T, P1, MP1> CCThreadTaskImpl;
  45
  46     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, P1 parameter1)
  47     {
  48         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1));
  49     }
  50
  51 private:
  52     CCThreadTask1(T* instance, Method method, P1 parameter1)
  53         : CCThread::Task(instance)
  54         , m_method(method)
  55         , m_parameter1(parameter1)
  56     {
  57     }
  58
  59     virtual void performTask() OVERRIDE
  60     {
  61         (*static_cast<T*>(instance()).*m_method)(m_parameter1);
  62     }
  63
  64 private:
  65     Method m_method;
  66     P1 m_parameter1;
  67 };
  68
  69 template<typename T, typename P1, typename MP1, typename P2, typename MP2>
  70 class CCThreadTask2 : public CCThread::Task {
  71 public:
  72     typedef void (T::*Method)(MP1, MP2);
  73     typedef CCThreadTask2<T, P1, MP1, P2, MP2> CCThreadTaskImpl;
  74
  75     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, P1 parameter1, P2 parameter2)
  76     {
  77         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2));
  78     }
  79
  80 private:
  81     CCThreadTask2(T* instance, Method method, P1 parameter1, P2 parameter2)
  82         : CCThread::Task(instance)
  83         , m_method(method)
  84         , m_parameter1(parameter1)
  85         , m_parameter2(parameter2)
  86     {
  87     }
  88
  89     virtual void performTask() OVERRIDE
  90     {
  91         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2);
  92     }
  93
  94 private:
  95     Method m_method;
  96     P1 m_parameter1;
  97     P2 m_parameter2;
  98 };
  99
 100 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 101 class CCThreadTask3 : public CCThread::Task {
 102 public:
 103     typedef void (T::*Method)(MP1, MP2, MP3);
 104     typedef CCThreadTask3<T, P1, MP1, P2, MP2, P3, MP3> CCThreadTaskImpl;
 105
 106     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3)
 107     {
 108         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3));
 109     }
 110
 111 private:
 112     CCThreadTask3(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3)
 113         : CCThread::Task(instance)
 114         , m_method(method)
 115         , m_parameter1(parameter1)
 116         , m_parameter2(parameter2)
 117         , m_parameter3(parameter3)
 118     {
 119     }
 120
 121     virtual void performTask() OVERRIDE
 122     {
 123         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3);
 124     }
 125
 126 private:
 127     Method m_method;
 128     P1 m_parameter1;
 129     P2 m_parameter2;
 130     P3 m_parameter3;
 131 };
 132
 133
 134 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 135 class CCThreadTask4 : public CCThread::Task {
 136 public:
 137     typedef void (T::*Method)(MP1, MP2, MP3, MP4);
 138     typedef CCThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4> CCThreadTaskImpl;
 139
 140     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4)
 141     {
 142         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4));
 143     }
 144
 145 private:
 146     CCThreadTask4(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4)
 147         : CCThread::Task(instance)
 148         , m_method(method)
 149         , m_parameter1(parameter1)
 150         , m_parameter2(parameter2)
 151         , m_parameter3(parameter3)
 152         , m_parameter4(parameter4)
 153     {
 154     }
 155
 156     virtual void performTask() OVERRIDE
 157     {
 158         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4);
 159     }
 160
 161 private:
 162     Method m_method;
 163     P1 m_parameter1;
 164     P2 m_parameter2;
 165     P3 m_parameter3;
 166     P4 m_parameter4;
 167 };
 168
 169 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 170 class CCThreadTask5 : public CCThread::Task {
 171 public:
 172     typedef void (T::*Method)(MP1, MP2, MP3, MP4, MP5);
 173     typedef CCThreadTask5<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5> CCThreadTaskImpl;
 174
 175     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5)
 176     {
 177         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4, parameter5));
 178     }
 179
 180 private:
 181     CCThreadTask5(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5)
 182         : CCThread::Task(instance)
 183         , m_method(method)
 184         , m_parameter1(parameter1)
 185         , m_parameter2(parameter2)
 186         , m_parameter3(parameter3)
 187         , m_parameter4(parameter4)
 188         , m_parameter5(parameter5)
 189     {
 190     }
 191
 192     virtual void performTask() OVERRIDE
 193     {
 194         (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5);
 195     }
 196
 197 private:
 198     Method m_method;
 199     P1 m_parameter1;
 200     P2 m_parameter2;
 201     P3 m_parameter3;
 202     P4 m_parameter4;
 203     P5 m_parameter5;
 204 };
 205
 206 template<typename T>
 207 PassOwnPtr<CCThread::Task> createCCThreadTask(
 208     T* const callee,
 209     void (T::*method)());
 210
 211 template<typename T>
 212 PassOwnPtr<CCThread::Task> createCCThreadTask(
 213     T* const callee,
 214     void (T::*method)())
 215 {
 216     return CCThreadTask0<T>::create(
 217         callee,
 218         method);
 219 }
 220
 221 template<typename T, typename P1, typename MP1>
 222 PassOwnPtr<CCThread::Task> createCCThreadTask(
 223     T* const callee,
 224     void (T::*method)(MP1),
 225     const P1& parameter1)
 226 {
 227     return CCThreadTask1<T, P1, MP1>::create(
 228         callee,
 229         method,
 230         parameter1);
 231 }
 232
 233 template<typename T, typename P1, typename MP1, typename P2, typename MP2>
 234 PassOwnPtr<CCThread::Task> createCCThreadTask(
 235     T* const callee,
 236     void (T::*method)(MP1, MP2),
 237     const P1& parameter1,
 238     const P2& parameter2)
 239 {
 240     return CCThreadTask2<T, P1, MP1, P2, MP2>::create(
 241         callee,
 242         method,
 243         parameter1,
 244         parameter2);
 245 }
 246
 247 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 248 PassOwnPtr<CCThread::Task> createCCThreadTask(
 249     T* const callee,
 250     void (T::*method)(MP1, MP2, MP3),
 251     const P1& parameter1,
 252     const P2& parameter2,
 253     const P3& parameter3)
 254 {
 255     return CCThreadTask3<T, P1, MP1, P2, MP2, P3, MP3>::create(
 256         callee,
 257         method,
 258         parameter1,
 259         parameter2,
 260         parameter3);
 261 }
 262
 263 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 264 PassOwnPtr<CCThread::Task> createCCThreadTask(
 265     T* const callee,
 266     void (T::*method)(MP1, MP2, MP3, MP4),
 267     const P1& parameter1,
 268     const P2& parameter2,
 269     const P3& parameter3,
 270     const P4& parameter4)
 271 {
 272     return CCThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4>::create(
 273         callee,
 274         method,
 275         parameter1,
 276         parameter2,
 277         parameter3,
 278         parameter4);
 279
 280 }
 281
 282 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 283 PassOwnPtr<CCThread::Task> createCCThreadTask(
 284     T* const callee,
 285     void (T::*method)(MP1, MP2, MP3, MP4, MP5),
 286     const P1& parameter1,
 287     const P2& parameter2,
 288     const P3& parameter3,
 289     const P4& parameter4,
 290     const P5& parameter5)
 291 {
 292     return CCThreadTask5<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5>::create(
 293         callee,
 294         method,
 295         parameter1,
 296         parameter2,
 297         parameter3,
 298         parameter4,
 299         parameter5);
 300
 301 }
 302
 303 } // namespace WebCore
 304
 305 #endif // CCThreadTask_h