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