WebCore/workers/GenericWorkerTask.h

   1 /*
   2  * Copyright (C) 2009 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 are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef GenericWorkerTask_h
  32 #define GenericWorkerTask_h
  33
  34 #if ENABLE(WORKERS)
  35
  36 #include "CrossThreadCopier.h"
  37 #include "ScriptExecutionContext.h"
  38 #include <memory>
  39 #include <wtf/PassRefPtr.h>
  40 #include <wtf/TypeTraits.h>
  41
  42 namespace WebCore {
  43
  44     // Traits for the GenericWorkerTask.
  45     template<typename T> struct GenericWorkerTaskTraits {
  46         typedef const T& ParamType;
  47     };
  48
  49     template<typename T> struct GenericWorkerTaskTraits<T*> {
  50         typedef T* ParamType;
  51     };
  52
  53     template<typename T> struct GenericWorkerTaskTraits<std::auto_ptr<T> > {
  54         typedef std::auto_ptr<T> ParamType;
  55     };
  56
  57     template<typename T> struct GenericWorkerTaskTraits<PassRefPtr<T> > {
  58         typedef PassRefPtr<T> ParamType;
  59     };
  60
  61     template<typename P1, typename MP1>
  62     class GenericWorkerTask1 : public ScriptExecutionContext::Task {
  63     public:
  64         typedef void (*Method)(ScriptExecutionContext*, MP1);
  65         typedef GenericWorkerTask1<P1, MP1> GenericWorkerTask;
  66         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
  67
  68         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1)
  69         {
  70             return adoptRef(new GenericWorkerTask(method, parameter1));
  71         }
  72
  73     private:
  74         GenericWorkerTask1(Method method, Param1 parameter1)
  75             : m_method(method)
  76             , m_parameter1(parameter1)
  77         {
  78         }
  79
  80         virtual void performTask(ScriptExecutionContext* context)
  81         {
  82             (*m_method)(context, m_parameter1);
  83         }
  84
  85     private:
  86         Method m_method;
  87         P1 m_parameter1;
  88     };
  89
  90     template<typename P1, typename MP1, typename P2, typename MP2>
  91     class GenericWorkerTask2 : public ScriptExecutionContext::Task {
  92     public:
  93         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2);
  94         typedef GenericWorkerTask2<P1, MP1, P2, MP2> GenericWorkerTask;
  95         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
  96         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
  97
  98         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2)
  99         {
 100             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2));
 101         }
 102
 103     private:
 104         GenericWorkerTask2(Method method, Param1 parameter1, Param2 parameter2)
 105             : m_method(method)
 106             , m_parameter1(parameter1)
 107             , m_parameter2(parameter2)
 108         {
 109         }
 110
 111         virtual void performTask(ScriptExecutionContext* context)
 112         {
 113             (*m_method)(context, m_parameter1, m_parameter2);
 114         }
 115
 116     private:
 117         Method m_method;
 118         P1 m_parameter1;
 119         P2 m_parameter2;
 120     };
 121
 122     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 123     class GenericWorkerTask3 : public ScriptExecutionContext::Task {
 124     public:
 125         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2, MP3);
 126         typedef GenericWorkerTask3<P1, MP1, P2, MP2, P3, MP3> GenericWorkerTask;
 127         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
 128         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
 129         typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
 130
 131         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
 132         {
 133             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3));
 134         }
 135
 136     private:
 137         GenericWorkerTask3(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
 138             : m_method(method)
 139             , m_parameter1(parameter1)
 140             , m_parameter2(parameter2)
 141             , m_parameter3(parameter3)
 142         {
 143         }
 144
 145         virtual void performTask(ScriptExecutionContext* context)
 146         {
 147             (*m_method)(context, m_parameter1, m_parameter2, m_parameter3);
 148         }
 149
 150     private:
 151         Method m_method;
 152         P1 m_parameter1;
 153         P2 m_parameter2;
 154         P3 m_parameter3;
 155     };
 156
 157     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 158     class GenericWorkerTask4 : public ScriptExecutionContext::Task {
 159     public:
 160         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4);
 161         typedef GenericWorkerTask4<P1, MP1, P2, MP2, P3, MP3, P4, MP4> GenericWorkerTask;
 162         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
 163         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
 164         typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
 165         typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
 166
 167         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
 168         {
 169             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4));
 170         }
 171
 172     private:
 173         GenericWorkerTask4(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
 174             : m_method(method)
 175             , m_parameter1(parameter1)
 176             , m_parameter2(parameter2)
 177             , m_parameter3(parameter3)
 178             , m_parameter4(parameter4)
 179         {
 180         }
 181
 182         virtual void performTask(ScriptExecutionContext* context)
 183         {
 184             (*m_method)(context, m_parameter1, m_parameter2, m_parameter3, m_parameter4);
 185         }
 186
 187     private:
 188         Method m_method;
 189         P1 m_parameter1;
 190         P2 m_parameter2;
 191         P3 m_parameter3;
 192         P4 m_parameter4;
 193     };
 194
 195     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 196     class GenericWorkerTask5 : public ScriptExecutionContext::Task {
 197     public:
 198         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5);
 199         typedef GenericWorkerTask5<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5> GenericWorkerTask;
 200         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
 201         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
 202         typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
 203         typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
 204         typedef typename GenericWorkerTaskTraits<P5>::ParamType Param5;
 205
 206         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
 207         {
 208             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5));
 209         }
 210
 211     private:
 212         GenericWorkerTask5(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
 213             : m_method(method)
 214             , m_parameter1(parameter1)
 215             , m_parameter2(parameter2)
 216             , m_parameter3(parameter3)
 217             , m_parameter4(parameter4)
 218             , m_parameter5(parameter5)
 219         {
 220         }
 221
 222         virtual void performTask(ScriptExecutionContext* context)
 223         {
 224             (*m_method)(context, m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5);
 225         }
 226
 227     private:
 228         Method m_method;
 229         P1 m_parameter1;
 230         P2 m_parameter2;
 231         P3 m_parameter3;
 232         P4 m_parameter4;
 233         P5 m_parameter5;
 234     };
 235
 236     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6>
 237     class GenericWorkerTask6 : public ScriptExecutionContext::Task {
 238     public:
 239         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6);
 240         typedef GenericWorkerTask6<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5, P6, MP6> GenericWorkerTask;
 241         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
 242         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
 243         typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
 244         typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
 245         typedef typename GenericWorkerTaskTraits<P5>::ParamType Param5;
 246         typedef typename GenericWorkerTaskTraits<P6>::ParamType Param6;
 247
 248         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
 249         {
 250             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6));
 251         }
 252
 253     private:
 254         GenericWorkerTask6(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
 255             : m_method(method)
 256             , m_parameter1(parameter1)
 257             , m_parameter2(parameter2)
 258             , m_parameter3(parameter3)
 259             , m_parameter4(parameter4)
 260             , m_parameter5(parameter5)
 261             , m_parameter6(parameter6)
 262         {
 263         }
 264
 265         virtual void performTask(ScriptExecutionContext* context)
 266         {
 267             (*m_method)(context, m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5, m_parameter6);
 268         }
 269
 270     private:
 271         Method m_method;
 272         P1 m_parameter1;
 273         P2 m_parameter2;
 274         P3 m_parameter3;
 275         P4 m_parameter4;
 276         P5 m_parameter5;
 277         P6 m_parameter6;
 278     };
 279
 280     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6, typename P7, typename MP7>
 281     class GenericWorkerTask7 : public ScriptExecutionContext::Task {
 282     public:
 283         typedef void (*Method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6, MP7);
 284         typedef GenericWorkerTask7<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5, P6, MP6, P7, MP7> GenericWorkerTask;
 285         typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
 286         typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
 287         typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
 288         typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
 289         typedef typename GenericWorkerTaskTraits<P5>::ParamType Param5;
 290         typedef typename GenericWorkerTaskTraits<P6>::ParamType Param6;
 291         typedef typename GenericWorkerTaskTraits<P7>::ParamType Param7;
 292
 293         static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
 294         {
 295             return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7));
 296         }
 297
 298     private:
 299         GenericWorkerTask7(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
 300             : m_method(method)
 301             , m_parameter1(parameter1)
 302             , m_parameter2(parameter2)
 303             , m_parameter3(parameter3)
 304             , m_parameter4(parameter4)
 305             , m_parameter5(parameter5)
 306             , m_parameter6(parameter6)
 307             , m_parameter7(parameter7)
 308         {
 309         }
 310
 311         virtual void performTask(ScriptExecutionContext* context)
 312         {
 313             (*m_method)(context, m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5, m_parameter6, m_parameter7);
 314         }
 315
 316     private:
 317         Method m_method;
 318         P1 m_parameter1;
 319         P2 m_parameter2;
 320         P3 m_parameter3;
 321         P4 m_parameter4;
 322         P5 m_parameter5;
 323         P6 m_parameter6;
 324         P7 m_parameter7;
 325     };
 326
 327     template<typename P1, typename MP1>
 328     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 329         void (*method)(ScriptExecutionContext*, MP1),
 330         const P1& parameter1)
 331     {
 332         return GenericWorkerTask1<typename CrossThreadCopier<P1>::Type, MP1>::create(
 333             method,
 334             CrossThreadCopier<P1>::copy(parameter1));
 335     }
 336
 337     template<typename P1, typename MP1, typename P2, typename MP2>
 338     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 339         void (*method)(ScriptExecutionContext*, MP1, MP2),
 340         const P1& parameter1, const P2& parameter2)
 341     {
 342         return GenericWorkerTask2<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
 343             method,
 344             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2));
 345     }
 346
 347     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
 348     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 349         void (*method)(ScriptExecutionContext*, MP1, MP2, MP3),
 350         const P1& parameter1, const P2& parameter2, const P3& parameter3)
 351     {
 352         return GenericWorkerTask3<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
 353             method,
 354             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
 355             CrossThreadCopier<P3>::copy(parameter3));
 356     }
 357
 358     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
 359     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 360         void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4),
 361         const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4)
 362     {
 363         return GenericWorkerTask4<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
 364             typename CrossThreadCopier<P4>::Type, MP4>::create(
 365                 method,
 366                 CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
 367                 CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4));
 368     }
 369
 370     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
 371     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 372         void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5),
 373         const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5)
 374     {
 375         return GenericWorkerTask5<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
 376             typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5>::create(
 377                 method,
 378                 CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
 379                 CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
 380                 CrossThreadCopier<P5>::copy(parameter5));
 381     }
 382
 383     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6>
 384     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 385         void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6),
 386         const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6)
 387     {
 388         return GenericWorkerTask6<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
 389             typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5, typename CrossThreadCopier<P6>::Type, MP6>::create(
 390                 method,
 391                 CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
 392                 CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
 393                 CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6));
 394     }
 395
 396     template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6, typename P7, typename MP7>
 397     PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
 398         void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6, MP7),
 399         const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6, const P7& parameter7)
 400     {
 401         return GenericWorkerTask7<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
 402             typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5, typename CrossThreadCopier<P6>::Type, MP6,
 403             typename CrossThreadCopier<P7>::Type, MP7>::create(
 404                 method,
 405                 CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
 406                 CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
 407                 CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6),
 408                 CrossThreadCopier<P7>::copy(parameter7));
 409     }
 410
 411 } // namespace WebCore
 412
 413 #endif // ENABLE(WORKERS)
 414
 415 #endif // GenericWorkerTask_h