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