Home | History | Annotate | Download | only in cc 
      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 CCThreadTask_h
     25 #define CCThreadTask_h
     26 
     27 #include "CCThread.h"
     28 #include "CrossThreadCopier.h"
     29 #include "CrossThreadTask.h"
     30 #include <wtf/PassOwnPtr.h>
     31 #include <wtf/PassRefPtr.h>
     32 
     33 namespace WebCore {
     34 
     35 template<typename T>
     36 class CCThreadTask0 : public CCThread::Task {
     37 public:
     38     typedef void (T::*Method)();
     39     typedef CCThreadTask0<T> CCThreadTaskImpl;
     40 
     41     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method)
     42     {
     43         return adoptPtr(new CCThreadTaskImpl(instance, method));
     44     }
     45 
     46 private:
     47     CCThreadTask0(T* instance, Method method)
     48         : CCThread::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 CCThreadTask1 : public CCThread::Task {
     64 public:
     65     typedef void (T::*Method)(MP1);
     66     typedef CCThreadTask1<T, P1, MP1> CCThreadTaskImpl;
     67     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
     68 
     69     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, Param1 parameter1)
     70     {
     71         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1));
     72     }
     73 
     74 private:
     75     CCThreadTask1(T* instance, Method method, Param1 parameter1)
     76         : CCThread::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 CCThreadTask2 : public CCThread::Task {
     94 public:
     95     typedef void (T::*Method)(MP1, MP2);
     96     typedef CCThreadTask2<T, P1, MP1, P2, MP2> CCThreadTaskImpl;
     97     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
     98     typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
     99 
    100     static PassOwnPtr<CCThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2)
    101     {
    102         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2));
    103     }
    104 
    105 private:
    106     CCThreadTask2(T* instance, Method method, Param1 parameter1, Param2 parameter2)
    107         : CCThread::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 CCThreadTask3 : public CCThread::Task {
    127 public:
    128     typedef void (T::*Method)(MP1, MP2, MP3);
    129     typedef CCThreadTask3<T, P1, MP1, P2, MP2, P3, MP3> CCThreadTaskImpl;
    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<CCThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    135     {
    136         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3));
    137     }
    138 
    139 private:
    140     CCThreadTask3(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    141         : CCThread::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 CCThreadTask4 : public CCThread::Task {
    164 public:
    165     typedef void (T::*Method)(MP1, MP2, MP3, MP4);
    166     typedef CCThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4> CCThreadTaskImpl;
    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<CCThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
    173     {
    174         return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4));
    175     }
    176 
    177 private:
    178     CCThreadTask4(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
    179         : CCThread::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>
    202 PassOwnPtr<CCThread::Task> createCCThreadTask(
    203     T* const callee,
    204     void (T::*method)());
    205 
    206 template<typename T>
    207 PassOwnPtr<CCThread::Task> createCCThreadTask(
    208     T* const callee,
    209     void (T::*method)())
    210 {
    211     return CCThreadTask0<T>::create(
    212         callee,
    213         method);
    214 }
    215 
    216 template<typename T, typename P1, typename MP1>
    217 PassOwnPtr<CCThread::Task> createCCThreadTask(
    218     T* const callee,
    219     void (T::*method)(MP1),
    220     const P1& parameter1)
    221 {
    222     return CCThreadTask1<T, typename CrossThreadCopier<P1>::Type, MP1>::create(
    223         callee,
    224         method,
    225         CrossThreadCopier<P1>::copy(parameter1));
    226 }
    227 
    228 template<typename T, typename P1, typename MP1, typename P2, typename MP2>
    229 PassOwnPtr<CCThread::Task> createCCThreadTask(
    230     T* const callee,
    231     void (T::*method)(MP1, MP2),
    232     const P1& parameter1,
    233     const P2& parameter2)
    234 {
    235     return CCThreadTask2<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
    236         callee,
    237         method,
    238         CrossThreadCopier<P1>::copy(parameter1),
    239         CrossThreadCopier<P2>::copy(parameter2));
    240 }
    241 
    242 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
    243 PassOwnPtr<CCThread::Task> createCCThreadTask(
    244     T* const callee,
    245     void (T::*method)(MP1, MP2, MP3),
    246     const P1& parameter1,
    247     const P2& parameter2,
    248     const P3& parameter3)
    249 {
    250     return CCThreadTask3<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
    251         callee,
    252         method,
    253         CrossThreadCopier<P1>::copy(parameter1),
    254         CrossThreadCopier<P2>::copy(parameter2),
    255         CrossThreadCopier<P3>::copy(parameter3));
    256 }
    257 
    258 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
    259 PassOwnPtr<CCThread::Task> createCCThreadTask(
    260     T* const callee,
    261     void (T::*method)(MP1, MP2, MP3, MP4),
    262     const P1& parameter1,
    263     const P2& parameter2,
    264     const P3& parameter3,
    265     const P4& parameter4)
    266 {
    267     return CCThreadTask4<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3, typename CrossThreadCopier<P4>::Type, MP4>::create(
    268         callee,
    269         method,
    270         CrossThreadCopier<P1>::copy(parameter1),
    271         CrossThreadCopier<P2>::copy(parameter2),
    272         CrossThreadCopier<P3>::copy(parameter3),
    273         CrossThreadCopier<P4>::copy(parameter4));
    274 
    275 }
    276 
    277 } // namespace WebCore
    278 
    279 #endif // CCThreadTask_h
    280