Name all the GLib timeout sources
[WebKit-https.git] / Source / WebCore / platform / MainThreadTask.h
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
41 namespace WebCore {
42
43 // Traits for the MainThreadTask.
44 template<typename T> struct MainThreadTaskTraits {
45     typedef const T& ParamType;
46 };
47
48 template<typename T> struct MainThreadTaskTraits<T*> {
49     typedef T* ParamType;
50 };
51
52 template<typename T> struct MainThreadTaskTraits<PassRefPtr<T>> {
53     typedef PassRefPtr<T> ParamType;
54 };
55
56 template<typename T> struct MainThreadTaskTraits<PassOwnPtr<T>> {
57     typedef PassOwnPtr<T> ParamType;
58 };
59
60 class MainThreadTaskBase {
61 WTF_MAKE_NONCOPYABLE(MainThreadTaskBase);
62 WTF_MAKE_FAST_ALLOCATED;
63 public:
64     MainThreadTaskBase() { }
65     virtual void performTask() = 0;
66     virtual ~MainThreadTaskBase() { }
67 };
68
69 template<typename P1, typename MP1>
70 class MainThreadTask1 : public MainThreadTaskBase {
71 public:
72     typedef void (*Method)(MP1);
73     typedef MainThreadTask1<P1, MP1> MainThreadTask;
74     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
75
76     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1)
77     {
78         return adoptPtr(new MainThreadTask(method, parameter1));
79     }
80
81 private:
82     MainThreadTask1(Method method, Param1 parameter1)
83         : m_method(method)
84         , m_parameter1(parameter1)
85     {
86     }
87
88     virtual void performTask() OVERRIDE
89     {
90         (*m_method)(m_parameter1);
91     }
92
93 private:
94     Method m_method;
95     P1 m_parameter1;
96 };
97
98 template<typename P1, typename MP1, typename P2, typename MP2>
99 class MainThreadTask2 : public MainThreadTaskBase {
100 public:
101     typedef void (*Method)(MP1, MP2);
102     typedef MainThreadTask2<P1, MP1, P2, MP2> MainThreadTask;
103     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
104     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
105
106     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2)
107     {
108         return adoptPtr(new MainThreadTask(method, parameter1, parameter2));
109     }
110
111 private:
112     MainThreadTask2(Method method, Param1 parameter1, Param2 parameter2)
113         : m_method(method)
114         , m_parameter1(parameter1)
115         , m_parameter2(parameter2)
116     {
117     }
118
119     virtual void performTask() OVERRIDE
120     {
121         (*m_method)(m_parameter1, m_parameter2);
122     }
123
124 private:
125     Method m_method;
126     P1 m_parameter1;
127     P2 m_parameter2;
128 };
129
130 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
131 class MainThreadTask3 : public MainThreadTaskBase {
132 public:
133     typedef void (*Method)(MP1, MP2, MP3);
134     typedef MainThreadTask3<P1, MP1, P2, MP2, P3, MP3> MainThreadTask;
135     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
136     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
137     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
138
139     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
140     {
141         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3));
142     }
143
144 private:
145     MainThreadTask3(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
146         : m_method(method)
147         , m_parameter1(parameter1)
148         , m_parameter2(parameter2)
149         , m_parameter3(parameter3)
150     {
151     }
152
153     virtual void performTask() OVERRIDE
154     {
155         (*m_method)(m_parameter1, m_parameter2, m_parameter3);
156     }
157
158 private:
159     Method m_method;
160     P1 m_parameter1;
161     P2 m_parameter2;
162     P3 m_parameter3;
163 };
164
165 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
166 class MainThreadTask4 : public MainThreadTaskBase {
167 public:
168     typedef void (*Method)(MP1, MP2, MP3, MP4);
169     typedef MainThreadTask4<P1, MP1, P2, MP2, P3, MP3, P4, MP4> MainThreadTask;
170     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
171     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
172     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
173     typedef typename MainThreadTaskTraits<P4>::ParamType Param4;
174
175     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
176     {
177         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3, parameter4));
178     }
179
180 private:
181     MainThreadTask4(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
182         : m_method(method)
183         , m_parameter1(parameter1)
184         , m_parameter2(parameter2)
185         , m_parameter3(parameter3)
186         , m_parameter4(parameter4)
187     {
188     }
189
190     virtual void performTask() OVERRIDE
191     {
192         (*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4);
193     }
194
195 private:
196     Method m_method;
197     P1 m_parameter1;
198     P2 m_parameter2;
199     P3 m_parameter3;
200     P4 m_parameter4;
201 };
202
203 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
204 class MainThreadTask5 : public MainThreadTaskBase {
205 public:
206     typedef void (*Method)(MP1, MP2, MP3, MP4, MP5);
207     typedef MainThreadTask5<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5> MainThreadTask;
208     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
209     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
210     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
211     typedef typename MainThreadTaskTraits<P4>::ParamType Param4;
212     typedef typename MainThreadTaskTraits<P5>::ParamType Param5;
213
214     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
215     {
216         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3, parameter4, parameter5));
217     }
218
219 private:
220     MainThreadTask5(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
221         : m_method(method)
222         , m_parameter1(parameter1)
223         , m_parameter2(parameter2)
224         , m_parameter3(parameter3)
225         , m_parameter4(parameter4)
226         , m_parameter5(parameter5)
227     {
228     }
229
230     virtual void performTask() OVERRIDE
231     {
232         (*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5);
233     }
234
235 private:
236     Method m_method;
237     P1 m_parameter1;
238     P2 m_parameter2;
239     P3 m_parameter3;
240     P4 m_parameter4;
241     P5 m_parameter5;
242 };
243
244 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>
245 class MainThreadTask6 : public MainThreadTaskBase {
246 public:
247     typedef void (*Method)(MP1, MP2, MP3, MP4, MP5, MP6);
248     typedef MainThreadTask6<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5, P6, MP6> MainThreadTask;
249     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
250     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
251     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
252     typedef typename MainThreadTaskTraits<P4>::ParamType Param4;
253     typedef typename MainThreadTaskTraits<P5>::ParamType Param5;
254     typedef typename MainThreadTaskTraits<P6>::ParamType Param6;
255
256     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
257     {
258         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6));
259     }
260
261 private:
262     MainThreadTask6(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
263         : m_method(method)
264         , m_parameter1(parameter1)
265         , m_parameter2(parameter2)
266         , m_parameter3(parameter3)
267         , m_parameter4(parameter4)
268         , m_parameter5(parameter5)
269         , m_parameter6(parameter6)
270     {
271     }
272
273     virtual void performTask() OVERRIDE
274     {
275         (*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5, m_parameter6);
276     }
277
278 private:
279     Method m_method;
280     P1 m_parameter1;
281     P2 m_parameter2;
282     P3 m_parameter3;
283     P4 m_parameter4;
284     P5 m_parameter5;
285     P6 m_parameter6;
286 };
287
288 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>
289 class MainThreadTask7 : public MainThreadTaskBase {
290 public:
291     typedef void (*Method)(MP1, MP2, MP3, MP4, MP5, MP6, MP7);
292     typedef MainThreadTask7<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5, P6, MP6, P7, MP7> MainThreadTask;
293     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
294     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
295     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
296     typedef typename MainThreadTaskTraits<P4>::ParamType Param4;
297     typedef typename MainThreadTaskTraits<P5>::ParamType Param5;
298     typedef typename MainThreadTaskTraits<P6>::ParamType Param6;
299     typedef typename MainThreadTaskTraits<P7>::ParamType Param7;
300
301     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
302     {
303         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7));
304     }
305
306 private:
307     MainThreadTask7(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
308         : m_method(method)
309         , m_parameter1(parameter1)
310         , m_parameter2(parameter2)
311         , m_parameter3(parameter3)
312         , m_parameter4(parameter4)
313         , m_parameter5(parameter5)
314         , m_parameter6(parameter6)
315         , m_parameter7(parameter7)
316     {
317     }
318
319     virtual void performTask() OVERRIDE
320     {
321         (*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5, m_parameter6, m_parameter7);
322     }
323
324 private:
325     Method m_method;
326     P1 m_parameter1;
327     P2 m_parameter2;
328     P3 m_parameter3;
329     P4 m_parameter4;
330     P5 m_parameter5;
331     P6 m_parameter6;
332     P7 m_parameter7;
333 };
334
335 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, typename P8, typename MP8>
336 class MainThreadTask8 : public MainThreadTaskBase {
337 public:
338     typedef void (*Method)(MP1, MP2, MP3, MP4, MP5, MP6, MP7, MP8);
339     typedef MainThreadTask8<P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5, P6, MP6, P7, MP7, P8, MP8> MainThreadTask;
340     typedef typename MainThreadTaskTraits<P1>::ParamType Param1;
341     typedef typename MainThreadTaskTraits<P2>::ParamType Param2;
342     typedef typename MainThreadTaskTraits<P3>::ParamType Param3;
343     typedef typename MainThreadTaskTraits<P4>::ParamType Param4;
344     typedef typename MainThreadTaskTraits<P5>::ParamType Param5;
345     typedef typename MainThreadTaskTraits<P6>::ParamType Param6;
346     typedef typename MainThreadTaskTraits<P7>::ParamType Param7;
347     typedef typename MainThreadTaskTraits<P8>::ParamType Param8;
348     
349     static PassOwnPtr<MainThreadTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7, Param8 parameter8)
350     {
351         return adoptPtr(new MainThreadTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7, parameter8));
352     }
353     
354 private:
355     MainThreadTask8(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7, Param8 parameter8)
356         : m_method(method)
357         , m_parameter1(parameter1)
358         , m_parameter2(parameter2)
359         , m_parameter3(parameter3)
360         , m_parameter4(parameter4)
361         , m_parameter5(parameter5)
362         , m_parameter6(parameter6)
363         , m_parameter7(parameter7)
364         , m_parameter8(parameter8)
365     {
366     }
367     
368     virtual void performTask() OVERRIDE
369     {
370         (*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5, m_parameter6, m_parameter7, m_parameter8);
371     }
372     
373 private:
374     Method m_method;
375     P1 m_parameter1;
376     P2 m_parameter2;
377     P3 m_parameter3;
378     P4 m_parameter4;
379     P5 m_parameter5;
380     P6 m_parameter6;
381     P7 m_parameter7;
382     P8 m_parameter8;
383 };
384
385 static void executeMainThreadTask(void* context)
386 {
387     OwnPtr<MainThreadTaskBase> task = adoptPtr(static_cast<MainThreadTaskBase*>(context));
388     task->performTask();
389 }
390
391 template<typename P1, typename MP1>
392 void callOnMainThread(
393     void (*method)(MP1),
394     const P1& parameter1)
395 {
396     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask1<typename CrossThreadCopier<P1>::Type, MP1>::create(
397         method,
398         CrossThreadCopier<P1>::copy(parameter1)).leakPtr());
399 }
400
401 template<typename P1, typename MP1, typename P2, typename MP2>
402 void callOnMainThread(
403     void (*method)(MP1, MP2),
404     const P1& parameter1, const P2& parameter2)
405 {
406     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask2<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
407         method,
408         CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2)).leakPtr());
409 }
410
411 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
412 void callOnMainThread(
413     void (*method)(MP1, MP2, MP3),
414     const P1& parameter1, const P2& parameter2, const P3& parameter3)
415 {
416     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask3<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
417         method,
418         CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
419         CrossThreadCopier<P3>::copy(parameter3)).leakPtr());
420 }
421
422 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
423 void callOnMainThread(
424     void (*method)(MP1, MP2, MP3, MP4),
425     const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4)
426 {
427     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask4<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
428         typename CrossThreadCopier<P4>::Type, MP4>::create(
429             method,
430             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
431             CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4)).leakPtr());
432 }
433
434 template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
435 void callOnMainThread(
436     void (*method)(MP1, MP2, MP3, MP4, MP5),
437     const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5)
438 {
439     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask5<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
440         typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5>::create(
441             method,
442             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
443             CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
444             CrossThreadCopier<P5>::copy(parameter5)).leakPtr());
445 }
446
447 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>
448 void callOnMainThread(
449     void (*method)(MP1, MP2, MP3, MP4, MP5, MP6),
450     const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6)
451 {
452     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask6<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
453         typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5, typename CrossThreadCopier<P6>::Type, MP6>::create(
454             method,
455             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
456             CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
457             CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6)).leakPtr());
458 }
459
460 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>
461 void callOnMainThread(
462     void (*method)(MP1, MP2, MP3, MP4, MP5, MP6, MP7),
463     const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6, const P7& parameter7)
464 {
465     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask7<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
466         typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5, typename CrossThreadCopier<P6>::Type, MP6,
467         typename CrossThreadCopier<P7>::Type, MP7>::create(
468             method,
469             CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
470             CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
471             CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6),
472             CrossThreadCopier<P7>::copy(parameter7)).leakPtr());
473 }
474
475 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, typename P8, typename MP8>
476 void callOnMainThread(
477     void (*method)(MP1, MP2, MP3, MP4, MP5, MP6, MP7, MP8),
478     const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6, const P7& parameter7, const P8& parameter8)
479 {
480     WTF::callOnMainThread(executeMainThreadTask, MainThreadTask8<typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3,
481     typename CrossThreadCopier<P4>::Type, MP4, typename CrossThreadCopier<P5>::Type, MP5, typename CrossThreadCopier<P6>::Type, MP6,
482     typename CrossThreadCopier<P7>::Type, MP7, typename CrossThreadCopier<P8>::Type, MP8>::create(
483                                                        method,
484                                                        CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
485                                                        CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
486                                                        CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6),
487                                                        CrossThreadCopier<P7>::copy(parameter7), CrossThreadCopier<P8>::copy(parameter8)).leakPtr());
488 }
489
490 } // namespace WebCore
491
492
493 #endif // MainThreadTask_h