1// This file was GENERATED by command:
2//     pump.py bind_internal.h.pump
3// DO NOT EDIT BY HAND!!!
4
5
6// Copyright (c) 2011 The Chromium Authors. All rights reserved.
7// Use of this source code is governed by a BSD-style license that can be
8// found in the LICENSE file.
9
10#ifndef BASE_BIND_INTERNAL_H_
11#define BASE_BIND_INTERNAL_H_
12
13#include "base/bind_helpers.h"
14#include "base/callback_internal.h"
15#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
16#include "base/memory/weak_ptr.h"
17#include "base/template_util.h"
18#include "build/build_config.h"
19
20#if defined(OS_WIN)
21#include "base/bind_internal_win.h"
22#endif
23
24namespace base {
25namespace internal {
26
27// See base/callback.h for user documentation.
28//
29//
30// CONCEPTS:
31//  Runnable -- A type (really a type class) that has a single Run() method
32//              and a RunType typedef that corresponds to the type of Run().
33//              A Runnable can declare that it should treated like a method
34//              call by including a typedef named IsMethod.  The value of
35//              this typedef is NOT inspected, only the existence.  When a
36//              Runnable declares itself a method, Bind() will enforce special
37//              refcounting + WeakPtr handling semantics for the first
38//              parameter which is expected to be an object.
39//  Functor -- A copyable type representing something that should be called.
40//             All function pointers, Callback<>, and Runnables are functors
41//             even if the invocation syntax differs.
42//  RunType -- A function type (as opposed to function _pointer_ type) for
43//             a Run() function.  Usually just a convenience typedef.
44//  (Bound)ArgsType -- A function type that is being (ab)used to store the
45//                     types of set of arguments.  The "return" type is always
46//                     void here.  We use this hack so that we do not need
47//                     a new type name for each arity of type. (eg.,
48//                     BindState1, BindState2).  This makes forward
49//                     declarations and friending much much easier.
50//
51// Types:
52//  RunnableAdapter<> -- Wraps the various "function" pointer types into an
53//                       object that adheres to the Runnable interface.
54//                       There are |3*ARITY| RunnableAdapter types.
55//  FunctionTraits<> -- Type traits that unwrap a function signature into a
56//                      a set of easier to use typedefs.  Used mainly for
57//                      compile time asserts.
58//                      There are |ARITY| FunctionTraits types.
59//  ForceVoidReturn<> -- Helper class for translating function signatures to
60//                       equivalent forms with a "void" return type.
61//                    There are |ARITY| ForceVoidReturn types.
62//  FunctorTraits<> -- Type traits used determine the correct RunType and
63//                     RunnableType for a Functor.  This is where function
64//                     signature adapters are applied.
65//                    There are |ARITY| ForceVoidReturn types.
66//  MakeRunnable<> -- Takes a Functor and returns an object in the Runnable
67//                    type class that represents the underlying Functor.
68//                    There are |O(1)| MakeRunnable types.
69//  InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
70// Handle the differing syntaxes needed for WeakPtr<> support,
71//                    and for ignoring return values.  This is separate from
72//                    Invoker to avoid creating multiple version of Invoker<>
73//                    which grows at O(n^2) with the arity.
74//                    There are |k*ARITY| InvokeHelper types.
75//  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
76//               There are |(ARITY^2 + ARITY)/2| Invoketypes.
77//  BindState<> -- Stores the curried parameters, and is the main entry point
78//                 into the Bind() system, doing most of the type resolution.
79//                 There are ARITY BindState types.
80
81// RunnableAdapter<>
82//
83// The RunnableAdapter<> templates provide a uniform interface for invoking
84// a function pointer, method pointer, or const method pointer. The adapter
85// exposes a Run() method with an appropriate signature. Using this wrapper
86// allows for writing code that supports all three pointer types without
87// undue repetition.  Without it, a lot of code would need to be repeated 3
88// times.
89//
90// For method pointers and const method pointers the first argument to Run()
91// is considered to be the received of the method.  This is similar to STL's
92// mem_fun().
93//
94// This class also exposes a RunType typedef that is the function type of the
95// Run() function.
96//
97// If and only if the wrapper contains a method or const method pointer, an
98// IsMethod typedef is exposed.  The existence of this typedef (NOT the value)
99// marks that the wrapper should be considered a method wrapper.
100
101template <typename Functor>
102class RunnableAdapter;
103
104// Function: Arity 0.
105template <typename R>
106class RunnableAdapter<R(*)()> {
107 public:
108  typedef R (RunType)();
109
110  explicit RunnableAdapter(R(*function)())
111      : function_(function) {
112  }
113
114  R Run() {
115    return function_();
116  }
117
118 private:
119  R (*function_)();
120};
121
122// Method: Arity 0.
123template <typename R, typename T>
124class RunnableAdapter<R(T::*)()> {
125 public:
126  typedef R (RunType)(T*);
127  typedef true_type IsMethod;
128
129  explicit RunnableAdapter(R(T::*method)())
130      : method_(method) {
131  }
132
133  R Run(T* object) {
134    return (object->*method_)();
135  }
136
137 private:
138  R (T::*method_)();
139};
140
141// Const Method: Arity 0.
142template <typename R, typename T>
143class RunnableAdapter<R(T::*)() const> {
144 public:
145  typedef R (RunType)(const T*);
146  typedef true_type IsMethod;
147
148  explicit RunnableAdapter(R(T::*method)() const)
149      : method_(method) {
150  }
151
152  R Run(const T* object) {
153    return (object->*method_)();
154  }
155
156 private:
157  R (T::*method_)() const;
158};
159
160// Function: Arity 1.
161template <typename R, typename A1>
162class RunnableAdapter<R(*)(A1)> {
163 public:
164  typedef R (RunType)(A1);
165
166  explicit RunnableAdapter(R(*function)(A1))
167      : function_(function) {
168  }
169
170  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
171    return function_(CallbackForward(a1));
172  }
173
174 private:
175  R (*function_)(A1);
176};
177
178// Method: Arity 1.
179template <typename R, typename T, typename A1>
180class RunnableAdapter<R(T::*)(A1)> {
181 public:
182  typedef R (RunType)(T*, A1);
183  typedef true_type IsMethod;
184
185  explicit RunnableAdapter(R(T::*method)(A1))
186      : method_(method) {
187  }
188
189  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
190    return (object->*method_)(CallbackForward(a1));
191  }
192
193 private:
194  R (T::*method_)(A1);
195};
196
197// Const Method: Arity 1.
198template <typename R, typename T, typename A1>
199class RunnableAdapter<R(T::*)(A1) const> {
200 public:
201  typedef R (RunType)(const T*, A1);
202  typedef true_type IsMethod;
203
204  explicit RunnableAdapter(R(T::*method)(A1) const)
205      : method_(method) {
206  }
207
208  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
209    return (object->*method_)(CallbackForward(a1));
210  }
211
212 private:
213  R (T::*method_)(A1) const;
214};
215
216// Function: Arity 2.
217template <typename R, typename A1, typename A2>
218class RunnableAdapter<R(*)(A1, A2)> {
219 public:
220  typedef R (RunType)(A1, A2);
221
222  explicit RunnableAdapter(R(*function)(A1, A2))
223      : function_(function) {
224  }
225
226  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
227      typename CallbackParamTraits<A2>::ForwardType a2) {
228    return function_(CallbackForward(a1), CallbackForward(a2));
229  }
230
231 private:
232  R (*function_)(A1, A2);
233};
234
235// Method: Arity 2.
236template <typename R, typename T, typename A1, typename A2>
237class RunnableAdapter<R(T::*)(A1, A2)> {
238 public:
239  typedef R (RunType)(T*, A1, A2);
240  typedef true_type IsMethod;
241
242  explicit RunnableAdapter(R(T::*method)(A1, A2))
243      : method_(method) {
244  }
245
246  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
247      typename CallbackParamTraits<A2>::ForwardType a2) {
248    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
249  }
250
251 private:
252  R (T::*method_)(A1, A2);
253};
254
255// Const Method: Arity 2.
256template <typename R, typename T, typename A1, typename A2>
257class RunnableAdapter<R(T::*)(A1, A2) const> {
258 public:
259  typedef R (RunType)(const T*, A1, A2);
260  typedef true_type IsMethod;
261
262  explicit RunnableAdapter(R(T::*method)(A1, A2) const)
263      : method_(method) {
264  }
265
266  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
267      typename CallbackParamTraits<A2>::ForwardType a2) {
268    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
269  }
270
271 private:
272  R (T::*method_)(A1, A2) const;
273};
274
275// Function: Arity 3.
276template <typename R, typename A1, typename A2, typename A3>
277class RunnableAdapter<R(*)(A1, A2, A3)> {
278 public:
279  typedef R (RunType)(A1, A2, A3);
280
281  explicit RunnableAdapter(R(*function)(A1, A2, A3))
282      : function_(function) {
283  }
284
285  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
286      typename CallbackParamTraits<A2>::ForwardType a2,
287      typename CallbackParamTraits<A3>::ForwardType a3) {
288    return function_(CallbackForward(a1), CallbackForward(a2),
289        CallbackForward(a3));
290  }
291
292 private:
293  R (*function_)(A1, A2, A3);
294};
295
296// Method: Arity 3.
297template <typename R, typename T, typename A1, typename A2, typename A3>
298class RunnableAdapter<R(T::*)(A1, A2, A3)> {
299 public:
300  typedef R (RunType)(T*, A1, A2, A3);
301  typedef true_type IsMethod;
302
303  explicit RunnableAdapter(R(T::*method)(A1, A2, A3))
304      : method_(method) {
305  }
306
307  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
308      typename CallbackParamTraits<A2>::ForwardType a2,
309      typename CallbackParamTraits<A3>::ForwardType a3) {
310    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
311        CallbackForward(a3));
312  }
313
314 private:
315  R (T::*method_)(A1, A2, A3);
316};
317
318// Const Method: Arity 3.
319template <typename R, typename T, typename A1, typename A2, typename A3>
320class RunnableAdapter<R(T::*)(A1, A2, A3) const> {
321 public:
322  typedef R (RunType)(const T*, A1, A2, A3);
323  typedef true_type IsMethod;
324
325  explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const)
326      : method_(method) {
327  }
328
329  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
330      typename CallbackParamTraits<A2>::ForwardType a2,
331      typename CallbackParamTraits<A3>::ForwardType a3) {
332    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
333        CallbackForward(a3));
334  }
335
336 private:
337  R (T::*method_)(A1, A2, A3) const;
338};
339
340// Function: Arity 4.
341template <typename R, typename A1, typename A2, typename A3, typename A4>
342class RunnableAdapter<R(*)(A1, A2, A3, A4)> {
343 public:
344  typedef R (RunType)(A1, A2, A3, A4);
345
346  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4))
347      : function_(function) {
348  }
349
350  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
351      typename CallbackParamTraits<A2>::ForwardType a2,
352      typename CallbackParamTraits<A3>::ForwardType a3,
353      typename CallbackParamTraits<A4>::ForwardType a4) {
354    return function_(CallbackForward(a1), CallbackForward(a2),
355        CallbackForward(a3), CallbackForward(a4));
356  }
357
358 private:
359  R (*function_)(A1, A2, A3, A4);
360};
361
362// Method: Arity 4.
363template <typename R, typename T, typename A1, typename A2, typename A3,
364    typename A4>
365class RunnableAdapter<R(T::*)(A1, A2, A3, A4)> {
366 public:
367  typedef R (RunType)(T*, A1, A2, A3, A4);
368  typedef true_type IsMethod;
369
370  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4))
371      : method_(method) {
372  }
373
374  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
375      typename CallbackParamTraits<A2>::ForwardType a2,
376      typename CallbackParamTraits<A3>::ForwardType a3,
377      typename CallbackParamTraits<A4>::ForwardType a4) {
378    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
379        CallbackForward(a3), CallbackForward(a4));
380  }
381
382 private:
383  R (T::*method_)(A1, A2, A3, A4);
384};
385
386// Const Method: Arity 4.
387template <typename R, typename T, typename A1, typename A2, typename A3,
388    typename A4>
389class RunnableAdapter<R(T::*)(A1, A2, A3, A4) const> {
390 public:
391  typedef R (RunType)(const T*, A1, A2, A3, A4);
392  typedef true_type IsMethod;
393
394  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const)
395      : method_(method) {
396  }
397
398  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
399      typename CallbackParamTraits<A2>::ForwardType a2,
400      typename CallbackParamTraits<A3>::ForwardType a3,
401      typename CallbackParamTraits<A4>::ForwardType a4) {
402    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
403        CallbackForward(a3), CallbackForward(a4));
404  }
405
406 private:
407  R (T::*method_)(A1, A2, A3, A4) const;
408};
409
410// Function: Arity 5.
411template <typename R, typename A1, typename A2, typename A3, typename A4,
412    typename A5>
413class RunnableAdapter<R(*)(A1, A2, A3, A4, A5)> {
414 public:
415  typedef R (RunType)(A1, A2, A3, A4, A5);
416
417  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5))
418      : function_(function) {
419  }
420
421  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
422      typename CallbackParamTraits<A2>::ForwardType a2,
423      typename CallbackParamTraits<A3>::ForwardType a3,
424      typename CallbackParamTraits<A4>::ForwardType a4,
425      typename CallbackParamTraits<A5>::ForwardType a5) {
426    return function_(CallbackForward(a1), CallbackForward(a2),
427        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
428  }
429
430 private:
431  R (*function_)(A1, A2, A3, A4, A5);
432};
433
434// Method: Arity 5.
435template <typename R, typename T, typename A1, typename A2, typename A3,
436    typename A4, typename A5>
437class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5)> {
438 public:
439  typedef R (RunType)(T*, A1, A2, A3, A4, A5);
440  typedef true_type IsMethod;
441
442  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5))
443      : method_(method) {
444  }
445
446  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
447      typename CallbackParamTraits<A2>::ForwardType a2,
448      typename CallbackParamTraits<A3>::ForwardType a3,
449      typename CallbackParamTraits<A4>::ForwardType a4,
450      typename CallbackParamTraits<A5>::ForwardType a5) {
451    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
452        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
453  }
454
455 private:
456  R (T::*method_)(A1, A2, A3, A4, A5);
457};
458
459// Const Method: Arity 5.
460template <typename R, typename T, typename A1, typename A2, typename A3,
461    typename A4, typename A5>
462class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5) const> {
463 public:
464  typedef R (RunType)(const T*, A1, A2, A3, A4, A5);
465  typedef true_type IsMethod;
466
467  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const)
468      : method_(method) {
469  }
470
471  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
472      typename CallbackParamTraits<A2>::ForwardType a2,
473      typename CallbackParamTraits<A3>::ForwardType a3,
474      typename CallbackParamTraits<A4>::ForwardType a4,
475      typename CallbackParamTraits<A5>::ForwardType a5) {
476    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
477        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
478  }
479
480 private:
481  R (T::*method_)(A1, A2, A3, A4, A5) const;
482};
483
484// Function: Arity 6.
485template <typename R, typename A1, typename A2, typename A3, typename A4,
486    typename A5, typename A6>
487class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6)> {
488 public:
489  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
490
491  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6))
492      : function_(function) {
493  }
494
495  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
496      typename CallbackParamTraits<A2>::ForwardType a2,
497      typename CallbackParamTraits<A3>::ForwardType a3,
498      typename CallbackParamTraits<A4>::ForwardType a4,
499      typename CallbackParamTraits<A5>::ForwardType a5,
500      typename CallbackParamTraits<A6>::ForwardType a6) {
501    return function_(CallbackForward(a1), CallbackForward(a2),
502        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
503        CallbackForward(a6));
504  }
505
506 private:
507  R (*function_)(A1, A2, A3, A4, A5, A6);
508};
509
510// Method: Arity 6.
511template <typename R, typename T, typename A1, typename A2, typename A3,
512    typename A4, typename A5, typename A6>
513class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6)> {
514 public:
515  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6);
516  typedef true_type IsMethod;
517
518  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6))
519      : method_(method) {
520  }
521
522  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
523      typename CallbackParamTraits<A2>::ForwardType a2,
524      typename CallbackParamTraits<A3>::ForwardType a3,
525      typename CallbackParamTraits<A4>::ForwardType a4,
526      typename CallbackParamTraits<A5>::ForwardType a5,
527      typename CallbackParamTraits<A6>::ForwardType a6) {
528    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
529        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
530        CallbackForward(a6));
531  }
532
533 private:
534  R (T::*method_)(A1, A2, A3, A4, A5, A6);
535};
536
537// Const Method: Arity 6.
538template <typename R, typename T, typename A1, typename A2, typename A3,
539    typename A4, typename A5, typename A6>
540class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6) const> {
541 public:
542  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6);
543  typedef true_type IsMethod;
544
545  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const)
546      : method_(method) {
547  }
548
549  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
550      typename CallbackParamTraits<A2>::ForwardType a2,
551      typename CallbackParamTraits<A3>::ForwardType a3,
552      typename CallbackParamTraits<A4>::ForwardType a4,
553      typename CallbackParamTraits<A5>::ForwardType a5,
554      typename CallbackParamTraits<A6>::ForwardType a6) {
555    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
556        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
557        CallbackForward(a6));
558  }
559
560 private:
561  R (T::*method_)(A1, A2, A3, A4, A5, A6) const;
562};
563
564// Function: Arity 7.
565template <typename R, typename A1, typename A2, typename A3, typename A4,
566    typename A5, typename A6, typename A7>
567class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6, A7)> {
568 public:
569  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
570
571  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7))
572      : function_(function) {
573  }
574
575  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
576      typename CallbackParamTraits<A2>::ForwardType a2,
577      typename CallbackParamTraits<A3>::ForwardType a3,
578      typename CallbackParamTraits<A4>::ForwardType a4,
579      typename CallbackParamTraits<A5>::ForwardType a5,
580      typename CallbackParamTraits<A6>::ForwardType a6,
581      typename CallbackParamTraits<A7>::ForwardType a7) {
582    return function_(CallbackForward(a1), CallbackForward(a2),
583        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
584        CallbackForward(a6), CallbackForward(a7));
585  }
586
587 private:
588  R (*function_)(A1, A2, A3, A4, A5, A6, A7);
589};
590
591// Method: Arity 7.
592template <typename R, typename T, typename A1, typename A2, typename A3,
593    typename A4, typename A5, typename A6, typename A7>
594class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {
595 public:
596  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7);
597  typedef true_type IsMethod;
598
599  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7))
600      : method_(method) {
601  }
602
603  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
604      typename CallbackParamTraits<A2>::ForwardType a2,
605      typename CallbackParamTraits<A3>::ForwardType a3,
606      typename CallbackParamTraits<A4>::ForwardType a4,
607      typename CallbackParamTraits<A5>::ForwardType a5,
608      typename CallbackParamTraits<A6>::ForwardType a6,
609      typename CallbackParamTraits<A7>::ForwardType a7) {
610    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
611        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
612        CallbackForward(a6), CallbackForward(a7));
613  }
614
615 private:
616  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7);
617};
618
619// Const Method: Arity 7.
620template <typename R, typename T, typename A1, typename A2, typename A3,
621    typename A4, typename A5, typename A6, typename A7>
622class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {
623 public:
624  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7);
625  typedef true_type IsMethod;
626
627  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const)
628      : method_(method) {
629  }
630
631  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
632      typename CallbackParamTraits<A2>::ForwardType a2,
633      typename CallbackParamTraits<A3>::ForwardType a3,
634      typename CallbackParamTraits<A4>::ForwardType a4,
635      typename CallbackParamTraits<A5>::ForwardType a5,
636      typename CallbackParamTraits<A6>::ForwardType a6,
637      typename CallbackParamTraits<A7>::ForwardType a7) {
638    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
639        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
640        CallbackForward(a6), CallbackForward(a7));
641  }
642
643 private:
644  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const;
645};
646
647
648// FunctionTraits<>
649//
650// Breaks a function signature apart into typedefs for easier introspection.
651template <typename Sig>
652struct FunctionTraits;
653
654template <typename R>
655struct FunctionTraits<R()> {
656  typedef R ReturnType;
657};
658
659template <typename R, typename A1>
660struct FunctionTraits<R(A1)> {
661  typedef R ReturnType;
662  typedef A1 A1Type;
663};
664
665template <typename R, typename A1, typename A2>
666struct FunctionTraits<R(A1, A2)> {
667  typedef R ReturnType;
668  typedef A1 A1Type;
669  typedef A2 A2Type;
670};
671
672template <typename R, typename A1, typename A2, typename A3>
673struct FunctionTraits<R(A1, A2, A3)> {
674  typedef R ReturnType;
675  typedef A1 A1Type;
676  typedef A2 A2Type;
677  typedef A3 A3Type;
678};
679
680template <typename R, typename A1, typename A2, typename A3, typename A4>
681struct FunctionTraits<R(A1, A2, A3, A4)> {
682  typedef R ReturnType;
683  typedef A1 A1Type;
684  typedef A2 A2Type;
685  typedef A3 A3Type;
686  typedef A4 A4Type;
687};
688
689template <typename R, typename A1, typename A2, typename A3, typename A4,
690    typename A5>
691struct FunctionTraits<R(A1, A2, A3, A4, A5)> {
692  typedef R ReturnType;
693  typedef A1 A1Type;
694  typedef A2 A2Type;
695  typedef A3 A3Type;
696  typedef A4 A4Type;
697  typedef A5 A5Type;
698};
699
700template <typename R, typename A1, typename A2, typename A3, typename A4,
701    typename A5, typename A6>
702struct FunctionTraits<R(A1, A2, A3, A4, A5, A6)> {
703  typedef R ReturnType;
704  typedef A1 A1Type;
705  typedef A2 A2Type;
706  typedef A3 A3Type;
707  typedef A4 A4Type;
708  typedef A5 A5Type;
709  typedef A6 A6Type;
710};
711
712template <typename R, typename A1, typename A2, typename A3, typename A4,
713    typename A5, typename A6, typename A7>
714struct FunctionTraits<R(A1, A2, A3, A4, A5, A6, A7)> {
715  typedef R ReturnType;
716  typedef A1 A1Type;
717  typedef A2 A2Type;
718  typedef A3 A3Type;
719  typedef A4 A4Type;
720  typedef A5 A5Type;
721  typedef A6 A6Type;
722  typedef A7 A7Type;
723};
724
725
726// ForceVoidReturn<>
727//
728// Set of templates that support forcing the function return type to void.
729template <typename Sig>
730struct ForceVoidReturn;
731
732template <typename R>
733struct ForceVoidReturn<R()> {
734  typedef void(RunType)();
735};
736
737template <typename R, typename A1>
738struct ForceVoidReturn<R(A1)> {
739  typedef void(RunType)(A1);
740};
741
742template <typename R, typename A1, typename A2>
743struct ForceVoidReturn<R(A1, A2)> {
744  typedef void(RunType)(A1, A2);
745};
746
747template <typename R, typename A1, typename A2, typename A3>
748struct ForceVoidReturn<R(A1, A2, A3)> {
749  typedef void(RunType)(A1, A2, A3);
750};
751
752template <typename R, typename A1, typename A2, typename A3, typename A4>
753struct ForceVoidReturn<R(A1, A2, A3, A4)> {
754  typedef void(RunType)(A1, A2, A3, A4);
755};
756
757template <typename R, typename A1, typename A2, typename A3, typename A4,
758    typename A5>
759struct ForceVoidReturn<R(A1, A2, A3, A4, A5)> {
760  typedef void(RunType)(A1, A2, A3, A4, A5);
761};
762
763template <typename R, typename A1, typename A2, typename A3, typename A4,
764    typename A5, typename A6>
765struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6)> {
766  typedef void(RunType)(A1, A2, A3, A4, A5, A6);
767};
768
769template <typename R, typename A1, typename A2, typename A3, typename A4,
770    typename A5, typename A6, typename A7>
771struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6, A7)> {
772  typedef void(RunType)(A1, A2, A3, A4, A5, A6, A7);
773};
774
775
776// FunctorTraits<>
777//
778// See description at top of file.
779template <typename T>
780struct FunctorTraits {
781  typedef RunnableAdapter<T> RunnableType;
782  typedef typename RunnableType::RunType RunType;
783};
784
785template <typename T>
786struct FunctorTraits<IgnoreResultHelper<T> > {
787  typedef typename FunctorTraits<T>::RunnableType RunnableType;
788  typedef typename ForceVoidReturn<
789      typename RunnableType::RunType>::RunType RunType;
790};
791
792template <typename T>
793struct FunctorTraits<Callback<T> > {
794  typedef Callback<T> RunnableType;
795  typedef typename Callback<T>::RunType RunType;
796};
797
798
799// MakeRunnable<>
800//
801// Converts a passed in functor to a RunnableType using type inference.
802
803template <typename T>
804typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
805  return RunnableAdapter<T>(t);
806}
807
808template <typename T>
809typename FunctorTraits<T>::RunnableType
810MakeRunnable(const IgnoreResultHelper<T>& t) {
811  return MakeRunnable(t.functor_);
812}
813
814template <typename T>
815const typename FunctorTraits<Callback<T> >::RunnableType&
816MakeRunnable(const Callback<T>& t) {
817  DCHECK(!t.is_null());
818  return t;
819}
820
821
822// InvokeHelper<>
823//
824// There are 3 logical InvokeHelper<> specializations: normal, void-return,
825// WeakCalls.
826//
827// The normal type just calls the underlying runnable.
828//
829// We need a InvokeHelper to handle void return types in order to support
830// IgnoreResult().  Normally, if the Runnable's RunType had a void return,
831// the template system would just accept "return functor.Run()" ignoring
832// the fact that a void function is being used with return. This piece of
833// sugar breaks though when the Runnable's RunType is not void.  Thus, we
834// need a partial specialization to change the syntax to drop the "return"
835// from the invocation call.
836//
837// WeakCalls similarly need special syntax that is applied to the first
838// argument to check if they should no-op themselves.
839template <bool IsWeakCall, typename ReturnType, typename Runnable,
840          typename ArgsType>
841struct InvokeHelper;
842
843template <typename ReturnType, typename Runnable>
844struct InvokeHelper<false, ReturnType, Runnable,
845    void()>  {
846  static ReturnType MakeItSo(Runnable runnable) {
847    return runnable.Run();
848  }
849};
850
851template <typename Runnable>
852struct InvokeHelper<false, void, Runnable,
853    void()>  {
854  static void MakeItSo(Runnable runnable) {
855    runnable.Run();
856  }
857};
858
859template <typename ReturnType, typename Runnable,typename A1>
860struct InvokeHelper<false, ReturnType, Runnable,
861    void(A1)>  {
862  static ReturnType MakeItSo(Runnable runnable, A1 a1) {
863    return runnable.Run(CallbackForward(a1));
864  }
865};
866
867template <typename Runnable,typename A1>
868struct InvokeHelper<false, void, Runnable,
869    void(A1)>  {
870  static void MakeItSo(Runnable runnable, A1 a1) {
871    runnable.Run(CallbackForward(a1));
872  }
873};
874
875template <typename Runnable, typename BoundWeakPtr>
876struct InvokeHelper<true, void, Runnable,
877    void(BoundWeakPtr)>  {
878  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr) {
879    if (!weak_ptr.get()) {
880      return;
881    }
882    runnable.Run(weak_ptr.get());
883  }
884};
885
886template <typename ReturnType, typename Runnable,typename A1, typename A2>
887struct InvokeHelper<false, ReturnType, Runnable,
888    void(A1, A2)>  {
889  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) {
890    return runnable.Run(CallbackForward(a1), CallbackForward(a2));
891  }
892};
893
894template <typename Runnable,typename A1, typename A2>
895struct InvokeHelper<false, void, Runnable,
896    void(A1, A2)>  {
897  static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
898    runnable.Run(CallbackForward(a1), CallbackForward(a2));
899  }
900};
901
902template <typename Runnable, typename BoundWeakPtr, typename A2>
903struct InvokeHelper<true, void, Runnable,
904    void(BoundWeakPtr, A2)>  {
905  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2) {
906    if (!weak_ptr.get()) {
907      return;
908    }
909    runnable.Run(weak_ptr.get(), CallbackForward(a2));
910  }
911};
912
913template <typename ReturnType, typename Runnable,typename A1, typename A2,
914    typename A3>
915struct InvokeHelper<false, ReturnType, Runnable,
916    void(A1, A2, A3)>  {
917  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
918    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
919        CallbackForward(a3));
920  }
921};
922
923template <typename Runnable,typename A1, typename A2, typename A3>
924struct InvokeHelper<false, void, Runnable,
925    void(A1, A2, A3)>  {
926  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
927    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
928  }
929};
930
931template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3>
932struct InvokeHelper<true, void, Runnable,
933    void(BoundWeakPtr, A2, A3)>  {
934  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3) {
935    if (!weak_ptr.get()) {
936      return;
937    }
938    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3));
939  }
940};
941
942template <typename ReturnType, typename Runnable,typename A1, typename A2,
943    typename A3, typename A4>
944struct InvokeHelper<false, ReturnType, Runnable,
945    void(A1, A2, A3, A4)>  {
946  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
947    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
948        CallbackForward(a3), CallbackForward(a4));
949  }
950};
951
952template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
953struct InvokeHelper<false, void, Runnable,
954    void(A1, A2, A3, A4)>  {
955  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
956    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
957        CallbackForward(a4));
958  }
959};
960
961template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
962    typename A4>
963struct InvokeHelper<true, void, Runnable,
964    void(BoundWeakPtr, A2, A3, A4)>  {
965  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
966      A4 a4) {
967    if (!weak_ptr.get()) {
968      return;
969    }
970    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
971        CallbackForward(a4));
972  }
973};
974
975template <typename ReturnType, typename Runnable,typename A1, typename A2,
976    typename A3, typename A4, typename A5>
977struct InvokeHelper<false, ReturnType, Runnable,
978    void(A1, A2, A3, A4, A5)>  {
979  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
980      A5 a5) {
981    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
982        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
983  }
984};
985
986template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
987    typename A5>
988struct InvokeHelper<false, void, Runnable,
989    void(A1, A2, A3, A4, A5)>  {
990  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
991    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
992        CallbackForward(a4), CallbackForward(a5));
993  }
994};
995
996template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
997    typename A4, typename A5>
998struct InvokeHelper<true, void, Runnable,
999    void(BoundWeakPtr, A2, A3, A4, A5)>  {
1000  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
1001      A4 a4, A5 a5) {
1002    if (!weak_ptr.get()) {
1003      return;
1004    }
1005    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
1006        CallbackForward(a4), CallbackForward(a5));
1007  }
1008};
1009
1010template <typename ReturnType, typename Runnable,typename A1, typename A2,
1011    typename A3, typename A4, typename A5, typename A6>
1012struct InvokeHelper<false, ReturnType, Runnable,
1013    void(A1, A2, A3, A4, A5, A6)>  {
1014  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
1015      A5 a5, A6 a6) {
1016    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
1017        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
1018        CallbackForward(a6));
1019  }
1020};
1021
1022template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1023    typename A5, typename A6>
1024struct InvokeHelper<false, void, Runnable,
1025    void(A1, A2, A3, A4, A5, A6)>  {
1026  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1027      A6 a6) {
1028    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1029        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
1030  }
1031};
1032
1033template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
1034    typename A4, typename A5, typename A6>
1035struct InvokeHelper<true, void, Runnable,
1036    void(BoundWeakPtr, A2, A3, A4, A5, A6)>  {
1037  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
1038      A4 a4, A5 a5, A6 a6) {
1039    if (!weak_ptr.get()) {
1040      return;
1041    }
1042    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
1043        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
1044  }
1045};
1046
1047template <typename ReturnType, typename Runnable,typename A1, typename A2,
1048    typename A3, typename A4, typename A5, typename A6, typename A7>
1049struct InvokeHelper<false, ReturnType, Runnable,
1050    void(A1, A2, A3, A4, A5, A6, A7)>  {
1051  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
1052      A5 a5, A6 a6, A7 a7) {
1053    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
1054        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
1055        CallbackForward(a6), CallbackForward(a7));
1056  }
1057};
1058
1059template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1060    typename A5, typename A6, typename A7>
1061struct InvokeHelper<false, void, Runnable,
1062    void(A1, A2, A3, A4, A5, A6, A7)>  {
1063  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1064      A6 a6, A7 a7) {
1065    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1066        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
1067        CallbackForward(a7));
1068  }
1069};
1070
1071template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
1072    typename A4, typename A5, typename A6, typename A7>
1073struct InvokeHelper<true, void, Runnable,
1074    void(BoundWeakPtr, A2, A3, A4, A5, A6, A7)>  {
1075  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
1076      A4 a4, A5 a5, A6 a6, A7 a7) {
1077    if (!weak_ptr.get()) {
1078      return;
1079    }
1080    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
1081        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
1082        CallbackForward(a7));
1083  }
1084};
1085
1086#if !defined(_MSC_VER)
1087
1088template <typename ReturnType, typename Runnable, typename ArgsType>
1089struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
1090  // WeakCalls are only supported for functions with a void return type.
1091  // Otherwise, the function result would be undefined if the the WeakPtr<>
1092  // is invalidated.
1093  COMPILE_ASSERT(is_void<ReturnType>::value,
1094                 weak_ptrs_can_only_bind_to_methods_without_return_values);
1095};
1096
1097#endif
1098
1099// Invoker<>
1100//
1101// See description at the top of the file.
1102template <int NumBound, typename Storage, typename RunType>
1103struct Invoker;
1104
1105// Arity 0 -> 0.
1106template <typename StorageType, typename R>
1107struct Invoker<0, StorageType, R()> {
1108  typedef R(RunType)(BindStateBase*);
1109
1110  typedef R(UnboundRunType)();
1111
1112  static R Run(BindStateBase* base) {
1113    StorageType* storage = static_cast<StorageType*>(base);
1114
1115    // Local references to make debugger stepping easier. If in a debugger,
1116    // you really want to warp ahead and step through the
1117    // InvokeHelper<>::MakeItSo() call below.
1118
1119    return InvokeHelper<StorageType::IsWeakCall::value, R,
1120           typename StorageType::RunnableType,
1121           void()>
1122               ::MakeItSo(storage->runnable_);
1123  }
1124};
1125
1126// Arity 1 -> 1.
1127template <typename StorageType, typename R,typename X1>
1128struct Invoker<0, StorageType, R(X1)> {
1129  typedef R(RunType)(BindStateBase*,
1130      typename CallbackParamTraits<X1>::ForwardType);
1131
1132  typedef R(UnboundRunType)(X1);
1133
1134  static R Run(BindStateBase* base,
1135      typename CallbackParamTraits<X1>::ForwardType x1) {
1136    StorageType* storage = static_cast<StorageType*>(base);
1137
1138    // Local references to make debugger stepping easier. If in a debugger,
1139    // you really want to warp ahead and step through the
1140    // InvokeHelper<>::MakeItSo() call below.
1141
1142    return InvokeHelper<StorageType::IsWeakCall::value, R,
1143           typename StorageType::RunnableType,
1144           void(typename CallbackParamTraits<X1>::ForwardType x1)>
1145               ::MakeItSo(storage->runnable_, CallbackForward(x1));
1146  }
1147};
1148
1149// Arity 1 -> 0.
1150template <typename StorageType, typename R,typename X1>
1151struct Invoker<1, StorageType, R(X1)> {
1152  typedef R(RunType)(BindStateBase*);
1153
1154  typedef R(UnboundRunType)();
1155
1156  static R Run(BindStateBase* base) {
1157    StorageType* storage = static_cast<StorageType*>(base);
1158
1159    // Local references to make debugger stepping easier. If in a debugger,
1160    // you really want to warp ahead and step through the
1161    // InvokeHelper<>::MakeItSo() call below.
1162    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1163
1164    typename Bound1UnwrapTraits::ForwardType x1 =
1165        Bound1UnwrapTraits::Unwrap(storage->p1_);
1166    return InvokeHelper<StorageType::IsWeakCall::value, R,
1167           typename StorageType::RunnableType,
1168           void(typename Bound1UnwrapTraits::ForwardType)>
1169               ::MakeItSo(storage->runnable_, CallbackForward(x1));
1170  }
1171};
1172
1173// Arity 2 -> 2.
1174template <typename StorageType, typename R,typename X1, typename X2>
1175struct Invoker<0, StorageType, R(X1, X2)> {
1176  typedef R(RunType)(BindStateBase*,
1177      typename CallbackParamTraits<X1>::ForwardType,
1178      typename CallbackParamTraits<X2>::ForwardType);
1179
1180  typedef R(UnboundRunType)(X1, X2);
1181
1182  static R Run(BindStateBase* base,
1183      typename CallbackParamTraits<X1>::ForwardType x1,
1184      typename CallbackParamTraits<X2>::ForwardType x2) {
1185    StorageType* storage = static_cast<StorageType*>(base);
1186
1187    // Local references to make debugger stepping easier. If in a debugger,
1188    // you really want to warp ahead and step through the
1189    // InvokeHelper<>::MakeItSo() call below.
1190
1191    return InvokeHelper<StorageType::IsWeakCall::value, R,
1192           typename StorageType::RunnableType,
1193           void(typename CallbackParamTraits<X1>::ForwardType x1,
1194               typename CallbackParamTraits<X2>::ForwardType x2)>
1195               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1196                   CallbackForward(x2));
1197  }
1198};
1199
1200// Arity 2 -> 1.
1201template <typename StorageType, typename R,typename X1, typename X2>
1202struct Invoker<1, StorageType, R(X1, X2)> {
1203  typedef R(RunType)(BindStateBase*,
1204      typename CallbackParamTraits<X2>::ForwardType);
1205
1206  typedef R(UnboundRunType)(X2);
1207
1208  static R Run(BindStateBase* base,
1209      typename CallbackParamTraits<X2>::ForwardType x2) {
1210    StorageType* storage = static_cast<StorageType*>(base);
1211
1212    // Local references to make debugger stepping easier. If in a debugger,
1213    // you really want to warp ahead and step through the
1214    // InvokeHelper<>::MakeItSo() call below.
1215    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1216
1217    typename Bound1UnwrapTraits::ForwardType x1 =
1218        Bound1UnwrapTraits::Unwrap(storage->p1_);
1219    return InvokeHelper<StorageType::IsWeakCall::value, R,
1220           typename StorageType::RunnableType,
1221           void(typename Bound1UnwrapTraits::ForwardType,
1222               typename CallbackParamTraits<X2>::ForwardType x2)>
1223               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1224                   CallbackForward(x2));
1225  }
1226};
1227
1228// Arity 2 -> 0.
1229template <typename StorageType, typename R,typename X1, typename X2>
1230struct Invoker<2, StorageType, R(X1, X2)> {
1231  typedef R(RunType)(BindStateBase*);
1232
1233  typedef R(UnboundRunType)();
1234
1235  static R Run(BindStateBase* base) {
1236    StorageType* storage = static_cast<StorageType*>(base);
1237
1238    // Local references to make debugger stepping easier. If in a debugger,
1239    // you really want to warp ahead and step through the
1240    // InvokeHelper<>::MakeItSo() call below.
1241    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1242    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1243
1244    typename Bound1UnwrapTraits::ForwardType x1 =
1245        Bound1UnwrapTraits::Unwrap(storage->p1_);
1246    typename Bound2UnwrapTraits::ForwardType x2 =
1247        Bound2UnwrapTraits::Unwrap(storage->p2_);
1248    return InvokeHelper<StorageType::IsWeakCall::value, R,
1249           typename StorageType::RunnableType,
1250           void(typename Bound1UnwrapTraits::ForwardType,
1251               typename Bound2UnwrapTraits::ForwardType)>
1252               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1253                   CallbackForward(x2));
1254  }
1255};
1256
1257// Arity 3 -> 3.
1258template <typename StorageType, typename R,typename X1, typename X2,
1259    typename X3>
1260struct Invoker<0, StorageType, R(X1, X2, X3)> {
1261  typedef R(RunType)(BindStateBase*,
1262      typename CallbackParamTraits<X1>::ForwardType,
1263      typename CallbackParamTraits<X2>::ForwardType,
1264      typename CallbackParamTraits<X3>::ForwardType);
1265
1266  typedef R(UnboundRunType)(X1, X2, X3);
1267
1268  static R Run(BindStateBase* base,
1269      typename CallbackParamTraits<X1>::ForwardType x1,
1270      typename CallbackParamTraits<X2>::ForwardType x2,
1271      typename CallbackParamTraits<X3>::ForwardType x3) {
1272    StorageType* storage = static_cast<StorageType*>(base);
1273
1274    // Local references to make debugger stepping easier. If in a debugger,
1275    // you really want to warp ahead and step through the
1276    // InvokeHelper<>::MakeItSo() call below.
1277
1278    return InvokeHelper<StorageType::IsWeakCall::value, R,
1279           typename StorageType::RunnableType,
1280           void(typename CallbackParamTraits<X1>::ForwardType x1,
1281               typename CallbackParamTraits<X2>::ForwardType x2,
1282               typename CallbackParamTraits<X3>::ForwardType x3)>
1283               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1284                   CallbackForward(x2), CallbackForward(x3));
1285  }
1286};
1287
1288// Arity 3 -> 2.
1289template <typename StorageType, typename R,typename X1, typename X2,
1290    typename X3>
1291struct Invoker<1, StorageType, R(X1, X2, X3)> {
1292  typedef R(RunType)(BindStateBase*,
1293      typename CallbackParamTraits<X2>::ForwardType,
1294      typename CallbackParamTraits<X3>::ForwardType);
1295
1296  typedef R(UnboundRunType)(X2, X3);
1297
1298  static R Run(BindStateBase* base,
1299      typename CallbackParamTraits<X2>::ForwardType x2,
1300      typename CallbackParamTraits<X3>::ForwardType x3) {
1301    StorageType* storage = static_cast<StorageType*>(base);
1302
1303    // Local references to make debugger stepping easier. If in a debugger,
1304    // you really want to warp ahead and step through the
1305    // InvokeHelper<>::MakeItSo() call below.
1306    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1307
1308    typename Bound1UnwrapTraits::ForwardType x1 =
1309        Bound1UnwrapTraits::Unwrap(storage->p1_);
1310    return InvokeHelper<StorageType::IsWeakCall::value, R,
1311           typename StorageType::RunnableType,
1312           void(typename Bound1UnwrapTraits::ForwardType,
1313               typename CallbackParamTraits<X2>::ForwardType x2,
1314               typename CallbackParamTraits<X3>::ForwardType x3)>
1315               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1316                   CallbackForward(x2), CallbackForward(x3));
1317  }
1318};
1319
1320// Arity 3 -> 1.
1321template <typename StorageType, typename R,typename X1, typename X2,
1322    typename X3>
1323struct Invoker<2, StorageType, R(X1, X2, X3)> {
1324  typedef R(RunType)(BindStateBase*,
1325      typename CallbackParamTraits<X3>::ForwardType);
1326
1327  typedef R(UnboundRunType)(X3);
1328
1329  static R Run(BindStateBase* base,
1330      typename CallbackParamTraits<X3>::ForwardType x3) {
1331    StorageType* storage = static_cast<StorageType*>(base);
1332
1333    // Local references to make debugger stepping easier. If in a debugger,
1334    // you really want to warp ahead and step through the
1335    // InvokeHelper<>::MakeItSo() call below.
1336    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1337    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1338
1339    typename Bound1UnwrapTraits::ForwardType x1 =
1340        Bound1UnwrapTraits::Unwrap(storage->p1_);
1341    typename Bound2UnwrapTraits::ForwardType x2 =
1342        Bound2UnwrapTraits::Unwrap(storage->p2_);
1343    return InvokeHelper<StorageType::IsWeakCall::value, R,
1344           typename StorageType::RunnableType,
1345           void(typename Bound1UnwrapTraits::ForwardType,
1346               typename Bound2UnwrapTraits::ForwardType,
1347               typename CallbackParamTraits<X3>::ForwardType x3)>
1348               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1349                   CallbackForward(x2), CallbackForward(x3));
1350  }
1351};
1352
1353// Arity 3 -> 0.
1354template <typename StorageType, typename R,typename X1, typename X2,
1355    typename X3>
1356struct Invoker<3, StorageType, R(X1, X2, X3)> {
1357  typedef R(RunType)(BindStateBase*);
1358
1359  typedef R(UnboundRunType)();
1360
1361  static R Run(BindStateBase* base) {
1362    StorageType* storage = static_cast<StorageType*>(base);
1363
1364    // Local references to make debugger stepping easier. If in a debugger,
1365    // you really want to warp ahead and step through the
1366    // InvokeHelper<>::MakeItSo() call below.
1367    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1368    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1369    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1370
1371    typename Bound1UnwrapTraits::ForwardType x1 =
1372        Bound1UnwrapTraits::Unwrap(storage->p1_);
1373    typename Bound2UnwrapTraits::ForwardType x2 =
1374        Bound2UnwrapTraits::Unwrap(storage->p2_);
1375    typename Bound3UnwrapTraits::ForwardType x3 =
1376        Bound3UnwrapTraits::Unwrap(storage->p3_);
1377    return InvokeHelper<StorageType::IsWeakCall::value, R,
1378           typename StorageType::RunnableType,
1379           void(typename Bound1UnwrapTraits::ForwardType,
1380               typename Bound2UnwrapTraits::ForwardType,
1381               typename Bound3UnwrapTraits::ForwardType)>
1382               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1383                   CallbackForward(x2), CallbackForward(x3));
1384  }
1385};
1386
1387// Arity 4 -> 4.
1388template <typename StorageType, typename R,typename X1, typename X2,
1389    typename X3, typename X4>
1390struct Invoker<0, StorageType, R(X1, X2, X3, X4)> {
1391  typedef R(RunType)(BindStateBase*,
1392      typename CallbackParamTraits<X1>::ForwardType,
1393      typename CallbackParamTraits<X2>::ForwardType,
1394      typename CallbackParamTraits<X3>::ForwardType,
1395      typename CallbackParamTraits<X4>::ForwardType);
1396
1397  typedef R(UnboundRunType)(X1, X2, X3, X4);
1398
1399  static R Run(BindStateBase* base,
1400      typename CallbackParamTraits<X1>::ForwardType x1,
1401      typename CallbackParamTraits<X2>::ForwardType x2,
1402      typename CallbackParamTraits<X3>::ForwardType x3,
1403      typename CallbackParamTraits<X4>::ForwardType x4) {
1404    StorageType* storage = static_cast<StorageType*>(base);
1405
1406    // Local references to make debugger stepping easier. If in a debugger,
1407    // you really want to warp ahead and step through the
1408    // InvokeHelper<>::MakeItSo() call below.
1409
1410    return InvokeHelper<StorageType::IsWeakCall::value, R,
1411           typename StorageType::RunnableType,
1412           void(typename CallbackParamTraits<X1>::ForwardType x1,
1413               typename CallbackParamTraits<X2>::ForwardType x2,
1414               typename CallbackParamTraits<X3>::ForwardType x3,
1415               typename CallbackParamTraits<X4>::ForwardType x4)>
1416               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1417                   CallbackForward(x2), CallbackForward(x3),
1418                   CallbackForward(x4));
1419  }
1420};
1421
1422// Arity 4 -> 3.
1423template <typename StorageType, typename R,typename X1, typename X2,
1424    typename X3, typename X4>
1425struct Invoker<1, StorageType, R(X1, X2, X3, X4)> {
1426  typedef R(RunType)(BindStateBase*,
1427      typename CallbackParamTraits<X2>::ForwardType,
1428      typename CallbackParamTraits<X3>::ForwardType,
1429      typename CallbackParamTraits<X4>::ForwardType);
1430
1431  typedef R(UnboundRunType)(X2, X3, X4);
1432
1433  static R Run(BindStateBase* base,
1434      typename CallbackParamTraits<X2>::ForwardType x2,
1435      typename CallbackParamTraits<X3>::ForwardType x3,
1436      typename CallbackParamTraits<X4>::ForwardType x4) {
1437    StorageType* storage = static_cast<StorageType*>(base);
1438
1439    // Local references to make debugger stepping easier. If in a debugger,
1440    // you really want to warp ahead and step through the
1441    // InvokeHelper<>::MakeItSo() call below.
1442    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1443
1444    typename Bound1UnwrapTraits::ForwardType x1 =
1445        Bound1UnwrapTraits::Unwrap(storage->p1_);
1446    return InvokeHelper<StorageType::IsWeakCall::value, R,
1447           typename StorageType::RunnableType,
1448           void(typename Bound1UnwrapTraits::ForwardType,
1449               typename CallbackParamTraits<X2>::ForwardType x2,
1450               typename CallbackParamTraits<X3>::ForwardType x3,
1451               typename CallbackParamTraits<X4>::ForwardType x4)>
1452               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1453                   CallbackForward(x2), CallbackForward(x3),
1454                   CallbackForward(x4));
1455  }
1456};
1457
1458// Arity 4 -> 2.
1459template <typename StorageType, typename R,typename X1, typename X2,
1460    typename X3, typename X4>
1461struct Invoker<2, StorageType, R(X1, X2, X3, X4)> {
1462  typedef R(RunType)(BindStateBase*,
1463      typename CallbackParamTraits<X3>::ForwardType,
1464      typename CallbackParamTraits<X4>::ForwardType);
1465
1466  typedef R(UnboundRunType)(X3, X4);
1467
1468  static R Run(BindStateBase* base,
1469      typename CallbackParamTraits<X3>::ForwardType x3,
1470      typename CallbackParamTraits<X4>::ForwardType x4) {
1471    StorageType* storage = static_cast<StorageType*>(base);
1472
1473    // Local references to make debugger stepping easier. If in a debugger,
1474    // you really want to warp ahead and step through the
1475    // InvokeHelper<>::MakeItSo() call below.
1476    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1477    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1478
1479    typename Bound1UnwrapTraits::ForwardType x1 =
1480        Bound1UnwrapTraits::Unwrap(storage->p1_);
1481    typename Bound2UnwrapTraits::ForwardType x2 =
1482        Bound2UnwrapTraits::Unwrap(storage->p2_);
1483    return InvokeHelper<StorageType::IsWeakCall::value, R,
1484           typename StorageType::RunnableType,
1485           void(typename Bound1UnwrapTraits::ForwardType,
1486               typename Bound2UnwrapTraits::ForwardType,
1487               typename CallbackParamTraits<X3>::ForwardType x3,
1488               typename CallbackParamTraits<X4>::ForwardType x4)>
1489               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1490                   CallbackForward(x2), CallbackForward(x3),
1491                   CallbackForward(x4));
1492  }
1493};
1494
1495// Arity 4 -> 1.
1496template <typename StorageType, typename R,typename X1, typename X2,
1497    typename X3, typename X4>
1498struct Invoker<3, StorageType, R(X1, X2, X3, X4)> {
1499  typedef R(RunType)(BindStateBase*,
1500      typename CallbackParamTraits<X4>::ForwardType);
1501
1502  typedef R(UnboundRunType)(X4);
1503
1504  static R Run(BindStateBase* base,
1505      typename CallbackParamTraits<X4>::ForwardType x4) {
1506    StorageType* storage = static_cast<StorageType*>(base);
1507
1508    // Local references to make debugger stepping easier. If in a debugger,
1509    // you really want to warp ahead and step through the
1510    // InvokeHelper<>::MakeItSo() call below.
1511    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1512    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1513    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1514
1515    typename Bound1UnwrapTraits::ForwardType x1 =
1516        Bound1UnwrapTraits::Unwrap(storage->p1_);
1517    typename Bound2UnwrapTraits::ForwardType x2 =
1518        Bound2UnwrapTraits::Unwrap(storage->p2_);
1519    typename Bound3UnwrapTraits::ForwardType x3 =
1520        Bound3UnwrapTraits::Unwrap(storage->p3_);
1521    return InvokeHelper<StorageType::IsWeakCall::value, R,
1522           typename StorageType::RunnableType,
1523           void(typename Bound1UnwrapTraits::ForwardType,
1524               typename Bound2UnwrapTraits::ForwardType,
1525               typename Bound3UnwrapTraits::ForwardType,
1526               typename CallbackParamTraits<X4>::ForwardType x4)>
1527               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1528                   CallbackForward(x2), CallbackForward(x3),
1529                   CallbackForward(x4));
1530  }
1531};
1532
1533// Arity 4 -> 0.
1534template <typename StorageType, typename R,typename X1, typename X2,
1535    typename X3, typename X4>
1536struct Invoker<4, StorageType, R(X1, X2, X3, X4)> {
1537  typedef R(RunType)(BindStateBase*);
1538
1539  typedef R(UnboundRunType)();
1540
1541  static R Run(BindStateBase* base) {
1542    StorageType* storage = static_cast<StorageType*>(base);
1543
1544    // Local references to make debugger stepping easier. If in a debugger,
1545    // you really want to warp ahead and step through the
1546    // InvokeHelper<>::MakeItSo() call below.
1547    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1548    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1549    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1550    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1551
1552    typename Bound1UnwrapTraits::ForwardType x1 =
1553        Bound1UnwrapTraits::Unwrap(storage->p1_);
1554    typename Bound2UnwrapTraits::ForwardType x2 =
1555        Bound2UnwrapTraits::Unwrap(storage->p2_);
1556    typename Bound3UnwrapTraits::ForwardType x3 =
1557        Bound3UnwrapTraits::Unwrap(storage->p3_);
1558    typename Bound4UnwrapTraits::ForwardType x4 =
1559        Bound4UnwrapTraits::Unwrap(storage->p4_);
1560    return InvokeHelper<StorageType::IsWeakCall::value, R,
1561           typename StorageType::RunnableType,
1562           void(typename Bound1UnwrapTraits::ForwardType,
1563               typename Bound2UnwrapTraits::ForwardType,
1564               typename Bound3UnwrapTraits::ForwardType,
1565               typename Bound4UnwrapTraits::ForwardType)>
1566               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1567                   CallbackForward(x2), CallbackForward(x3),
1568                   CallbackForward(x4));
1569  }
1570};
1571
1572// Arity 5 -> 5.
1573template <typename StorageType, typename R,typename X1, typename X2,
1574    typename X3, typename X4, typename X5>
1575struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> {
1576  typedef R(RunType)(BindStateBase*,
1577      typename CallbackParamTraits<X1>::ForwardType,
1578      typename CallbackParamTraits<X2>::ForwardType,
1579      typename CallbackParamTraits<X3>::ForwardType,
1580      typename CallbackParamTraits<X4>::ForwardType,
1581      typename CallbackParamTraits<X5>::ForwardType);
1582
1583  typedef R(UnboundRunType)(X1, X2, X3, X4, X5);
1584
1585  static R Run(BindStateBase* base,
1586      typename CallbackParamTraits<X1>::ForwardType x1,
1587      typename CallbackParamTraits<X2>::ForwardType x2,
1588      typename CallbackParamTraits<X3>::ForwardType x3,
1589      typename CallbackParamTraits<X4>::ForwardType x4,
1590      typename CallbackParamTraits<X5>::ForwardType x5) {
1591    StorageType* storage = static_cast<StorageType*>(base);
1592
1593    // Local references to make debugger stepping easier. If in a debugger,
1594    // you really want to warp ahead and step through the
1595    // InvokeHelper<>::MakeItSo() call below.
1596
1597    return InvokeHelper<StorageType::IsWeakCall::value, R,
1598           typename StorageType::RunnableType,
1599           void(typename CallbackParamTraits<X1>::ForwardType x1,
1600               typename CallbackParamTraits<X2>::ForwardType x2,
1601               typename CallbackParamTraits<X3>::ForwardType x3,
1602               typename CallbackParamTraits<X4>::ForwardType x4,
1603               typename CallbackParamTraits<X5>::ForwardType x5)>
1604               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1605                   CallbackForward(x2), CallbackForward(x3),
1606                   CallbackForward(x4), CallbackForward(x5));
1607  }
1608};
1609
1610// Arity 5 -> 4.
1611template <typename StorageType, typename R,typename X1, typename X2,
1612    typename X3, typename X4, typename X5>
1613struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> {
1614  typedef R(RunType)(BindStateBase*,
1615      typename CallbackParamTraits<X2>::ForwardType,
1616      typename CallbackParamTraits<X3>::ForwardType,
1617      typename CallbackParamTraits<X4>::ForwardType,
1618      typename CallbackParamTraits<X5>::ForwardType);
1619
1620  typedef R(UnboundRunType)(X2, X3, X4, X5);
1621
1622  static R Run(BindStateBase* base,
1623      typename CallbackParamTraits<X2>::ForwardType x2,
1624      typename CallbackParamTraits<X3>::ForwardType x3,
1625      typename CallbackParamTraits<X4>::ForwardType x4,
1626      typename CallbackParamTraits<X5>::ForwardType x5) {
1627    StorageType* storage = static_cast<StorageType*>(base);
1628
1629    // Local references to make debugger stepping easier. If in a debugger,
1630    // you really want to warp ahead and step through the
1631    // InvokeHelper<>::MakeItSo() call below.
1632    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1633
1634    typename Bound1UnwrapTraits::ForwardType x1 =
1635        Bound1UnwrapTraits::Unwrap(storage->p1_);
1636    return InvokeHelper<StorageType::IsWeakCall::value, R,
1637           typename StorageType::RunnableType,
1638           void(typename Bound1UnwrapTraits::ForwardType,
1639               typename CallbackParamTraits<X2>::ForwardType x2,
1640               typename CallbackParamTraits<X3>::ForwardType x3,
1641               typename CallbackParamTraits<X4>::ForwardType x4,
1642               typename CallbackParamTraits<X5>::ForwardType x5)>
1643               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1644                   CallbackForward(x2), CallbackForward(x3),
1645                   CallbackForward(x4), CallbackForward(x5));
1646  }
1647};
1648
1649// Arity 5 -> 3.
1650template <typename StorageType, typename R,typename X1, typename X2,
1651    typename X3, typename X4, typename X5>
1652struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> {
1653  typedef R(RunType)(BindStateBase*,
1654      typename CallbackParamTraits<X3>::ForwardType,
1655      typename CallbackParamTraits<X4>::ForwardType,
1656      typename CallbackParamTraits<X5>::ForwardType);
1657
1658  typedef R(UnboundRunType)(X3, X4, X5);
1659
1660  static R Run(BindStateBase* base,
1661      typename CallbackParamTraits<X3>::ForwardType x3,
1662      typename CallbackParamTraits<X4>::ForwardType x4,
1663      typename CallbackParamTraits<X5>::ForwardType x5) {
1664    StorageType* storage = static_cast<StorageType*>(base);
1665
1666    // Local references to make debugger stepping easier. If in a debugger,
1667    // you really want to warp ahead and step through the
1668    // InvokeHelper<>::MakeItSo() call below.
1669    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1670    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1671
1672    typename Bound1UnwrapTraits::ForwardType x1 =
1673        Bound1UnwrapTraits::Unwrap(storage->p1_);
1674    typename Bound2UnwrapTraits::ForwardType x2 =
1675        Bound2UnwrapTraits::Unwrap(storage->p2_);
1676    return InvokeHelper<StorageType::IsWeakCall::value, R,
1677           typename StorageType::RunnableType,
1678           void(typename Bound1UnwrapTraits::ForwardType,
1679               typename Bound2UnwrapTraits::ForwardType,
1680               typename CallbackParamTraits<X3>::ForwardType x3,
1681               typename CallbackParamTraits<X4>::ForwardType x4,
1682               typename CallbackParamTraits<X5>::ForwardType x5)>
1683               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1684                   CallbackForward(x2), CallbackForward(x3),
1685                   CallbackForward(x4), CallbackForward(x5));
1686  }
1687};
1688
1689// Arity 5 -> 2.
1690template <typename StorageType, typename R,typename X1, typename X2,
1691    typename X3, typename X4, typename X5>
1692struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> {
1693  typedef R(RunType)(BindStateBase*,
1694      typename CallbackParamTraits<X4>::ForwardType,
1695      typename CallbackParamTraits<X5>::ForwardType);
1696
1697  typedef R(UnboundRunType)(X4, X5);
1698
1699  static R Run(BindStateBase* base,
1700      typename CallbackParamTraits<X4>::ForwardType x4,
1701      typename CallbackParamTraits<X5>::ForwardType x5) {
1702    StorageType* storage = static_cast<StorageType*>(base);
1703
1704    // Local references to make debugger stepping easier. If in a debugger,
1705    // you really want to warp ahead and step through the
1706    // InvokeHelper<>::MakeItSo() call below.
1707    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1708    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1709    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1710
1711    typename Bound1UnwrapTraits::ForwardType x1 =
1712        Bound1UnwrapTraits::Unwrap(storage->p1_);
1713    typename Bound2UnwrapTraits::ForwardType x2 =
1714        Bound2UnwrapTraits::Unwrap(storage->p2_);
1715    typename Bound3UnwrapTraits::ForwardType x3 =
1716        Bound3UnwrapTraits::Unwrap(storage->p3_);
1717    return InvokeHelper<StorageType::IsWeakCall::value, R,
1718           typename StorageType::RunnableType,
1719           void(typename Bound1UnwrapTraits::ForwardType,
1720               typename Bound2UnwrapTraits::ForwardType,
1721               typename Bound3UnwrapTraits::ForwardType,
1722               typename CallbackParamTraits<X4>::ForwardType x4,
1723               typename CallbackParamTraits<X5>::ForwardType x5)>
1724               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1725                   CallbackForward(x2), CallbackForward(x3),
1726                   CallbackForward(x4), CallbackForward(x5));
1727  }
1728};
1729
1730// Arity 5 -> 1.
1731template <typename StorageType, typename R,typename X1, typename X2,
1732    typename X3, typename X4, typename X5>
1733struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> {
1734  typedef R(RunType)(BindStateBase*,
1735      typename CallbackParamTraits<X5>::ForwardType);
1736
1737  typedef R(UnboundRunType)(X5);
1738
1739  static R Run(BindStateBase* base,
1740      typename CallbackParamTraits<X5>::ForwardType x5) {
1741    StorageType* storage = static_cast<StorageType*>(base);
1742
1743    // Local references to make debugger stepping easier. If in a debugger,
1744    // you really want to warp ahead and step through the
1745    // InvokeHelper<>::MakeItSo() call below.
1746    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1747    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1748    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1749    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1750
1751    typename Bound1UnwrapTraits::ForwardType x1 =
1752        Bound1UnwrapTraits::Unwrap(storage->p1_);
1753    typename Bound2UnwrapTraits::ForwardType x2 =
1754        Bound2UnwrapTraits::Unwrap(storage->p2_);
1755    typename Bound3UnwrapTraits::ForwardType x3 =
1756        Bound3UnwrapTraits::Unwrap(storage->p3_);
1757    typename Bound4UnwrapTraits::ForwardType x4 =
1758        Bound4UnwrapTraits::Unwrap(storage->p4_);
1759    return InvokeHelper<StorageType::IsWeakCall::value, R,
1760           typename StorageType::RunnableType,
1761           void(typename Bound1UnwrapTraits::ForwardType,
1762               typename Bound2UnwrapTraits::ForwardType,
1763               typename Bound3UnwrapTraits::ForwardType,
1764               typename Bound4UnwrapTraits::ForwardType,
1765               typename CallbackParamTraits<X5>::ForwardType x5)>
1766               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1767                   CallbackForward(x2), CallbackForward(x3),
1768                   CallbackForward(x4), CallbackForward(x5));
1769  }
1770};
1771
1772// Arity 5 -> 0.
1773template <typename StorageType, typename R,typename X1, typename X2,
1774    typename X3, typename X4, typename X5>
1775struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> {
1776  typedef R(RunType)(BindStateBase*);
1777
1778  typedef R(UnboundRunType)();
1779
1780  static R Run(BindStateBase* base) {
1781    StorageType* storage = static_cast<StorageType*>(base);
1782
1783    // Local references to make debugger stepping easier. If in a debugger,
1784    // you really want to warp ahead and step through the
1785    // InvokeHelper<>::MakeItSo() call below.
1786    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1787    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1788    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1789    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1790    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
1791
1792    typename Bound1UnwrapTraits::ForwardType x1 =
1793        Bound1UnwrapTraits::Unwrap(storage->p1_);
1794    typename Bound2UnwrapTraits::ForwardType x2 =
1795        Bound2UnwrapTraits::Unwrap(storage->p2_);
1796    typename Bound3UnwrapTraits::ForwardType x3 =
1797        Bound3UnwrapTraits::Unwrap(storage->p3_);
1798    typename Bound4UnwrapTraits::ForwardType x4 =
1799        Bound4UnwrapTraits::Unwrap(storage->p4_);
1800    typename Bound5UnwrapTraits::ForwardType x5 =
1801        Bound5UnwrapTraits::Unwrap(storage->p5_);
1802    return InvokeHelper<StorageType::IsWeakCall::value, R,
1803           typename StorageType::RunnableType,
1804           void(typename Bound1UnwrapTraits::ForwardType,
1805               typename Bound2UnwrapTraits::ForwardType,
1806               typename Bound3UnwrapTraits::ForwardType,
1807               typename Bound4UnwrapTraits::ForwardType,
1808               typename Bound5UnwrapTraits::ForwardType)>
1809               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1810                   CallbackForward(x2), CallbackForward(x3),
1811                   CallbackForward(x4), CallbackForward(x5));
1812  }
1813};
1814
1815// Arity 6 -> 6.
1816template <typename StorageType, typename R,typename X1, typename X2,
1817    typename X3, typename X4, typename X5, typename X6>
1818struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1819  typedef R(RunType)(BindStateBase*,
1820      typename CallbackParamTraits<X1>::ForwardType,
1821      typename CallbackParamTraits<X2>::ForwardType,
1822      typename CallbackParamTraits<X3>::ForwardType,
1823      typename CallbackParamTraits<X4>::ForwardType,
1824      typename CallbackParamTraits<X5>::ForwardType,
1825      typename CallbackParamTraits<X6>::ForwardType);
1826
1827  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6);
1828
1829  static R Run(BindStateBase* base,
1830      typename CallbackParamTraits<X1>::ForwardType x1,
1831      typename CallbackParamTraits<X2>::ForwardType x2,
1832      typename CallbackParamTraits<X3>::ForwardType x3,
1833      typename CallbackParamTraits<X4>::ForwardType x4,
1834      typename CallbackParamTraits<X5>::ForwardType x5,
1835      typename CallbackParamTraits<X6>::ForwardType x6) {
1836    StorageType* storage = static_cast<StorageType*>(base);
1837
1838    // Local references to make debugger stepping easier. If in a debugger,
1839    // you really want to warp ahead and step through the
1840    // InvokeHelper<>::MakeItSo() call below.
1841
1842    return InvokeHelper<StorageType::IsWeakCall::value, R,
1843           typename StorageType::RunnableType,
1844           void(typename CallbackParamTraits<X1>::ForwardType x1,
1845               typename CallbackParamTraits<X2>::ForwardType x2,
1846               typename CallbackParamTraits<X3>::ForwardType x3,
1847               typename CallbackParamTraits<X4>::ForwardType x4,
1848               typename CallbackParamTraits<X5>::ForwardType x5,
1849               typename CallbackParamTraits<X6>::ForwardType x6)>
1850               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1851                   CallbackForward(x2), CallbackForward(x3),
1852                   CallbackForward(x4), CallbackForward(x5),
1853                   CallbackForward(x6));
1854  }
1855};
1856
1857// Arity 6 -> 5.
1858template <typename StorageType, typename R,typename X1, typename X2,
1859    typename X3, typename X4, typename X5, typename X6>
1860struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1861  typedef R(RunType)(BindStateBase*,
1862      typename CallbackParamTraits<X2>::ForwardType,
1863      typename CallbackParamTraits<X3>::ForwardType,
1864      typename CallbackParamTraits<X4>::ForwardType,
1865      typename CallbackParamTraits<X5>::ForwardType,
1866      typename CallbackParamTraits<X6>::ForwardType);
1867
1868  typedef R(UnboundRunType)(X2, X3, X4, X5, X6);
1869
1870  static R Run(BindStateBase* base,
1871      typename CallbackParamTraits<X2>::ForwardType x2,
1872      typename CallbackParamTraits<X3>::ForwardType x3,
1873      typename CallbackParamTraits<X4>::ForwardType x4,
1874      typename CallbackParamTraits<X5>::ForwardType x5,
1875      typename CallbackParamTraits<X6>::ForwardType x6) {
1876    StorageType* storage = static_cast<StorageType*>(base);
1877
1878    // Local references to make debugger stepping easier. If in a debugger,
1879    // you really want to warp ahead and step through the
1880    // InvokeHelper<>::MakeItSo() call below.
1881    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1882
1883    typename Bound1UnwrapTraits::ForwardType x1 =
1884        Bound1UnwrapTraits::Unwrap(storage->p1_);
1885    return InvokeHelper<StorageType::IsWeakCall::value, R,
1886           typename StorageType::RunnableType,
1887           void(typename Bound1UnwrapTraits::ForwardType,
1888               typename CallbackParamTraits<X2>::ForwardType x2,
1889               typename CallbackParamTraits<X3>::ForwardType x3,
1890               typename CallbackParamTraits<X4>::ForwardType x4,
1891               typename CallbackParamTraits<X5>::ForwardType x5,
1892               typename CallbackParamTraits<X6>::ForwardType x6)>
1893               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1894                   CallbackForward(x2), CallbackForward(x3),
1895                   CallbackForward(x4), CallbackForward(x5),
1896                   CallbackForward(x6));
1897  }
1898};
1899
1900// Arity 6 -> 4.
1901template <typename StorageType, typename R,typename X1, typename X2,
1902    typename X3, typename X4, typename X5, typename X6>
1903struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1904  typedef R(RunType)(BindStateBase*,
1905      typename CallbackParamTraits<X3>::ForwardType,
1906      typename CallbackParamTraits<X4>::ForwardType,
1907      typename CallbackParamTraits<X5>::ForwardType,
1908      typename CallbackParamTraits<X6>::ForwardType);
1909
1910  typedef R(UnboundRunType)(X3, X4, X5, X6);
1911
1912  static R Run(BindStateBase* base,
1913      typename CallbackParamTraits<X3>::ForwardType x3,
1914      typename CallbackParamTraits<X4>::ForwardType x4,
1915      typename CallbackParamTraits<X5>::ForwardType x5,
1916      typename CallbackParamTraits<X6>::ForwardType x6) {
1917    StorageType* storage = static_cast<StorageType*>(base);
1918
1919    // Local references to make debugger stepping easier. If in a debugger,
1920    // you really want to warp ahead and step through the
1921    // InvokeHelper<>::MakeItSo() call below.
1922    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1923    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1924
1925    typename Bound1UnwrapTraits::ForwardType x1 =
1926        Bound1UnwrapTraits::Unwrap(storage->p1_);
1927    typename Bound2UnwrapTraits::ForwardType x2 =
1928        Bound2UnwrapTraits::Unwrap(storage->p2_);
1929    return InvokeHelper<StorageType::IsWeakCall::value, R,
1930           typename StorageType::RunnableType,
1931           void(typename Bound1UnwrapTraits::ForwardType,
1932               typename Bound2UnwrapTraits::ForwardType,
1933               typename CallbackParamTraits<X3>::ForwardType x3,
1934               typename CallbackParamTraits<X4>::ForwardType x4,
1935               typename CallbackParamTraits<X5>::ForwardType x5,
1936               typename CallbackParamTraits<X6>::ForwardType x6)>
1937               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1938                   CallbackForward(x2), CallbackForward(x3),
1939                   CallbackForward(x4), CallbackForward(x5),
1940                   CallbackForward(x6));
1941  }
1942};
1943
1944// Arity 6 -> 3.
1945template <typename StorageType, typename R,typename X1, typename X2,
1946    typename X3, typename X4, typename X5, typename X6>
1947struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1948  typedef R(RunType)(BindStateBase*,
1949      typename CallbackParamTraits<X4>::ForwardType,
1950      typename CallbackParamTraits<X5>::ForwardType,
1951      typename CallbackParamTraits<X6>::ForwardType);
1952
1953  typedef R(UnboundRunType)(X4, X5, X6);
1954
1955  static R Run(BindStateBase* base,
1956      typename CallbackParamTraits<X4>::ForwardType x4,
1957      typename CallbackParamTraits<X5>::ForwardType x5,
1958      typename CallbackParamTraits<X6>::ForwardType x6) {
1959    StorageType* storage = static_cast<StorageType*>(base);
1960
1961    // Local references to make debugger stepping easier. If in a debugger,
1962    // you really want to warp ahead and step through the
1963    // InvokeHelper<>::MakeItSo() call below.
1964    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1965    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1966    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1967
1968    typename Bound1UnwrapTraits::ForwardType x1 =
1969        Bound1UnwrapTraits::Unwrap(storage->p1_);
1970    typename Bound2UnwrapTraits::ForwardType x2 =
1971        Bound2UnwrapTraits::Unwrap(storage->p2_);
1972    typename Bound3UnwrapTraits::ForwardType x3 =
1973        Bound3UnwrapTraits::Unwrap(storage->p3_);
1974    return InvokeHelper<StorageType::IsWeakCall::value, R,
1975           typename StorageType::RunnableType,
1976           void(typename Bound1UnwrapTraits::ForwardType,
1977               typename Bound2UnwrapTraits::ForwardType,
1978               typename Bound3UnwrapTraits::ForwardType,
1979               typename CallbackParamTraits<X4>::ForwardType x4,
1980               typename CallbackParamTraits<X5>::ForwardType x5,
1981               typename CallbackParamTraits<X6>::ForwardType x6)>
1982               ::MakeItSo(storage->runnable_, CallbackForward(x1),
1983                   CallbackForward(x2), CallbackForward(x3),
1984                   CallbackForward(x4), CallbackForward(x5),
1985                   CallbackForward(x6));
1986  }
1987};
1988
1989// Arity 6 -> 2.
1990template <typename StorageType, typename R,typename X1, typename X2,
1991    typename X3, typename X4, typename X5, typename X6>
1992struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1993  typedef R(RunType)(BindStateBase*,
1994      typename CallbackParamTraits<X5>::ForwardType,
1995      typename CallbackParamTraits<X6>::ForwardType);
1996
1997  typedef R(UnboundRunType)(X5, X6);
1998
1999  static R Run(BindStateBase* base,
2000      typename CallbackParamTraits<X5>::ForwardType x5,
2001      typename CallbackParamTraits<X6>::ForwardType x6) {
2002    StorageType* storage = static_cast<StorageType*>(base);
2003
2004    // Local references to make debugger stepping easier. If in a debugger,
2005    // you really want to warp ahead and step through the
2006    // InvokeHelper<>::MakeItSo() call below.
2007    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2008    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2009    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2010    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2011
2012    typename Bound1UnwrapTraits::ForwardType x1 =
2013        Bound1UnwrapTraits::Unwrap(storage->p1_);
2014    typename Bound2UnwrapTraits::ForwardType x2 =
2015        Bound2UnwrapTraits::Unwrap(storage->p2_);
2016    typename Bound3UnwrapTraits::ForwardType x3 =
2017        Bound3UnwrapTraits::Unwrap(storage->p3_);
2018    typename Bound4UnwrapTraits::ForwardType x4 =
2019        Bound4UnwrapTraits::Unwrap(storage->p4_);
2020    return InvokeHelper<StorageType::IsWeakCall::value, R,
2021           typename StorageType::RunnableType,
2022           void(typename Bound1UnwrapTraits::ForwardType,
2023               typename Bound2UnwrapTraits::ForwardType,
2024               typename Bound3UnwrapTraits::ForwardType,
2025               typename Bound4UnwrapTraits::ForwardType,
2026               typename CallbackParamTraits<X5>::ForwardType x5,
2027               typename CallbackParamTraits<X6>::ForwardType x6)>
2028               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2029                   CallbackForward(x2), CallbackForward(x3),
2030                   CallbackForward(x4), CallbackForward(x5),
2031                   CallbackForward(x6));
2032  }
2033};
2034
2035// Arity 6 -> 1.
2036template <typename StorageType, typename R,typename X1, typename X2,
2037    typename X3, typename X4, typename X5, typename X6>
2038struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> {
2039  typedef R(RunType)(BindStateBase*,
2040      typename CallbackParamTraits<X6>::ForwardType);
2041
2042  typedef R(UnboundRunType)(X6);
2043
2044  static R Run(BindStateBase* base,
2045      typename CallbackParamTraits<X6>::ForwardType x6) {
2046    StorageType* storage = static_cast<StorageType*>(base);
2047
2048    // Local references to make debugger stepping easier. If in a debugger,
2049    // you really want to warp ahead and step through the
2050    // InvokeHelper<>::MakeItSo() call below.
2051    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2052    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2053    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2054    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2055    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2056
2057    typename Bound1UnwrapTraits::ForwardType x1 =
2058        Bound1UnwrapTraits::Unwrap(storage->p1_);
2059    typename Bound2UnwrapTraits::ForwardType x2 =
2060        Bound2UnwrapTraits::Unwrap(storage->p2_);
2061    typename Bound3UnwrapTraits::ForwardType x3 =
2062        Bound3UnwrapTraits::Unwrap(storage->p3_);
2063    typename Bound4UnwrapTraits::ForwardType x4 =
2064        Bound4UnwrapTraits::Unwrap(storage->p4_);
2065    typename Bound5UnwrapTraits::ForwardType x5 =
2066        Bound5UnwrapTraits::Unwrap(storage->p5_);
2067    return InvokeHelper<StorageType::IsWeakCall::value, R,
2068           typename StorageType::RunnableType,
2069           void(typename Bound1UnwrapTraits::ForwardType,
2070               typename Bound2UnwrapTraits::ForwardType,
2071               typename Bound3UnwrapTraits::ForwardType,
2072               typename Bound4UnwrapTraits::ForwardType,
2073               typename Bound5UnwrapTraits::ForwardType,
2074               typename CallbackParamTraits<X6>::ForwardType x6)>
2075               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2076                   CallbackForward(x2), CallbackForward(x3),
2077                   CallbackForward(x4), CallbackForward(x5),
2078                   CallbackForward(x6));
2079  }
2080};
2081
2082// Arity 6 -> 0.
2083template <typename StorageType, typename R,typename X1, typename X2,
2084    typename X3, typename X4, typename X5, typename X6>
2085struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> {
2086  typedef R(RunType)(BindStateBase*);
2087
2088  typedef R(UnboundRunType)();
2089
2090  static R Run(BindStateBase* base) {
2091    StorageType* storage = static_cast<StorageType*>(base);
2092
2093    // Local references to make debugger stepping easier. If in a debugger,
2094    // you really want to warp ahead and step through the
2095    // InvokeHelper<>::MakeItSo() call below.
2096    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2097    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2098    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2099    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2100    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2101    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2102
2103    typename Bound1UnwrapTraits::ForwardType x1 =
2104        Bound1UnwrapTraits::Unwrap(storage->p1_);
2105    typename Bound2UnwrapTraits::ForwardType x2 =
2106        Bound2UnwrapTraits::Unwrap(storage->p2_);
2107    typename Bound3UnwrapTraits::ForwardType x3 =
2108        Bound3UnwrapTraits::Unwrap(storage->p3_);
2109    typename Bound4UnwrapTraits::ForwardType x4 =
2110        Bound4UnwrapTraits::Unwrap(storage->p4_);
2111    typename Bound5UnwrapTraits::ForwardType x5 =
2112        Bound5UnwrapTraits::Unwrap(storage->p5_);
2113    typename Bound6UnwrapTraits::ForwardType x6 =
2114        Bound6UnwrapTraits::Unwrap(storage->p6_);
2115    return InvokeHelper<StorageType::IsWeakCall::value, R,
2116           typename StorageType::RunnableType,
2117           void(typename Bound1UnwrapTraits::ForwardType,
2118               typename Bound2UnwrapTraits::ForwardType,
2119               typename Bound3UnwrapTraits::ForwardType,
2120               typename Bound4UnwrapTraits::ForwardType,
2121               typename Bound5UnwrapTraits::ForwardType,
2122               typename Bound6UnwrapTraits::ForwardType)>
2123               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2124                   CallbackForward(x2), CallbackForward(x3),
2125                   CallbackForward(x4), CallbackForward(x5),
2126                   CallbackForward(x6));
2127  }
2128};
2129
2130// Arity 7 -> 7.
2131template <typename StorageType, typename R,typename X1, typename X2,
2132    typename X3, typename X4, typename X5, typename X6, typename X7>
2133struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2134  typedef R(RunType)(BindStateBase*,
2135      typename CallbackParamTraits<X1>::ForwardType,
2136      typename CallbackParamTraits<X2>::ForwardType,
2137      typename CallbackParamTraits<X3>::ForwardType,
2138      typename CallbackParamTraits<X4>::ForwardType,
2139      typename CallbackParamTraits<X5>::ForwardType,
2140      typename CallbackParamTraits<X6>::ForwardType,
2141      typename CallbackParamTraits<X7>::ForwardType);
2142
2143  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7);
2144
2145  static R Run(BindStateBase* base,
2146      typename CallbackParamTraits<X1>::ForwardType x1,
2147      typename CallbackParamTraits<X2>::ForwardType x2,
2148      typename CallbackParamTraits<X3>::ForwardType x3,
2149      typename CallbackParamTraits<X4>::ForwardType x4,
2150      typename CallbackParamTraits<X5>::ForwardType x5,
2151      typename CallbackParamTraits<X6>::ForwardType x6,
2152      typename CallbackParamTraits<X7>::ForwardType x7) {
2153    StorageType* storage = static_cast<StorageType*>(base);
2154
2155    // Local references to make debugger stepping easier. If in a debugger,
2156    // you really want to warp ahead and step through the
2157    // InvokeHelper<>::MakeItSo() call below.
2158
2159    return InvokeHelper<StorageType::IsWeakCall::value, R,
2160           typename StorageType::RunnableType,
2161           void(typename CallbackParamTraits<X1>::ForwardType x1,
2162               typename CallbackParamTraits<X2>::ForwardType x2,
2163               typename CallbackParamTraits<X3>::ForwardType x3,
2164               typename CallbackParamTraits<X4>::ForwardType x4,
2165               typename CallbackParamTraits<X5>::ForwardType x5,
2166               typename CallbackParamTraits<X6>::ForwardType x6,
2167               typename CallbackParamTraits<X7>::ForwardType x7)>
2168               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2169                   CallbackForward(x2), CallbackForward(x3),
2170                   CallbackForward(x4), CallbackForward(x5),
2171                   CallbackForward(x6), CallbackForward(x7));
2172  }
2173};
2174
2175// Arity 7 -> 6.
2176template <typename StorageType, typename R,typename X1, typename X2,
2177    typename X3, typename X4, typename X5, typename X6, typename X7>
2178struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2179  typedef R(RunType)(BindStateBase*,
2180      typename CallbackParamTraits<X2>::ForwardType,
2181      typename CallbackParamTraits<X3>::ForwardType,
2182      typename CallbackParamTraits<X4>::ForwardType,
2183      typename CallbackParamTraits<X5>::ForwardType,
2184      typename CallbackParamTraits<X6>::ForwardType,
2185      typename CallbackParamTraits<X7>::ForwardType);
2186
2187  typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7);
2188
2189  static R Run(BindStateBase* base,
2190      typename CallbackParamTraits<X2>::ForwardType x2,
2191      typename CallbackParamTraits<X3>::ForwardType x3,
2192      typename CallbackParamTraits<X4>::ForwardType x4,
2193      typename CallbackParamTraits<X5>::ForwardType x5,
2194      typename CallbackParamTraits<X6>::ForwardType x6,
2195      typename CallbackParamTraits<X7>::ForwardType x7) {
2196    StorageType* storage = static_cast<StorageType*>(base);
2197
2198    // Local references to make debugger stepping easier. If in a debugger,
2199    // you really want to warp ahead and step through the
2200    // InvokeHelper<>::MakeItSo() call below.
2201    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2202
2203    typename Bound1UnwrapTraits::ForwardType x1 =
2204        Bound1UnwrapTraits::Unwrap(storage->p1_);
2205    return InvokeHelper<StorageType::IsWeakCall::value, R,
2206           typename StorageType::RunnableType,
2207           void(typename Bound1UnwrapTraits::ForwardType,
2208               typename CallbackParamTraits<X2>::ForwardType x2,
2209               typename CallbackParamTraits<X3>::ForwardType x3,
2210               typename CallbackParamTraits<X4>::ForwardType x4,
2211               typename CallbackParamTraits<X5>::ForwardType x5,
2212               typename CallbackParamTraits<X6>::ForwardType x6,
2213               typename CallbackParamTraits<X7>::ForwardType x7)>
2214               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2215                   CallbackForward(x2), CallbackForward(x3),
2216                   CallbackForward(x4), CallbackForward(x5),
2217                   CallbackForward(x6), CallbackForward(x7));
2218  }
2219};
2220
2221// Arity 7 -> 5.
2222template <typename StorageType, typename R,typename X1, typename X2,
2223    typename X3, typename X4, typename X5, typename X6, typename X7>
2224struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2225  typedef R(RunType)(BindStateBase*,
2226      typename CallbackParamTraits<X3>::ForwardType,
2227      typename CallbackParamTraits<X4>::ForwardType,
2228      typename CallbackParamTraits<X5>::ForwardType,
2229      typename CallbackParamTraits<X6>::ForwardType,
2230      typename CallbackParamTraits<X7>::ForwardType);
2231
2232  typedef R(UnboundRunType)(X3, X4, X5, X6, X7);
2233
2234  static R Run(BindStateBase* base,
2235      typename CallbackParamTraits<X3>::ForwardType x3,
2236      typename CallbackParamTraits<X4>::ForwardType x4,
2237      typename CallbackParamTraits<X5>::ForwardType x5,
2238      typename CallbackParamTraits<X6>::ForwardType x6,
2239      typename CallbackParamTraits<X7>::ForwardType x7) {
2240    StorageType* storage = static_cast<StorageType*>(base);
2241
2242    // Local references to make debugger stepping easier. If in a debugger,
2243    // you really want to warp ahead and step through the
2244    // InvokeHelper<>::MakeItSo() call below.
2245    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2246    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2247
2248    typename Bound1UnwrapTraits::ForwardType x1 =
2249        Bound1UnwrapTraits::Unwrap(storage->p1_);
2250    typename Bound2UnwrapTraits::ForwardType x2 =
2251        Bound2UnwrapTraits::Unwrap(storage->p2_);
2252    return InvokeHelper<StorageType::IsWeakCall::value, R,
2253           typename StorageType::RunnableType,
2254           void(typename Bound1UnwrapTraits::ForwardType,
2255               typename Bound2UnwrapTraits::ForwardType,
2256               typename CallbackParamTraits<X3>::ForwardType x3,
2257               typename CallbackParamTraits<X4>::ForwardType x4,
2258               typename CallbackParamTraits<X5>::ForwardType x5,
2259               typename CallbackParamTraits<X6>::ForwardType x6,
2260               typename CallbackParamTraits<X7>::ForwardType x7)>
2261               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2262                   CallbackForward(x2), CallbackForward(x3),
2263                   CallbackForward(x4), CallbackForward(x5),
2264                   CallbackForward(x6), CallbackForward(x7));
2265  }
2266};
2267
2268// Arity 7 -> 4.
2269template <typename StorageType, typename R,typename X1, typename X2,
2270    typename X3, typename X4, typename X5, typename X6, typename X7>
2271struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2272  typedef R(RunType)(BindStateBase*,
2273      typename CallbackParamTraits<X4>::ForwardType,
2274      typename CallbackParamTraits<X5>::ForwardType,
2275      typename CallbackParamTraits<X6>::ForwardType,
2276      typename CallbackParamTraits<X7>::ForwardType);
2277
2278  typedef R(UnboundRunType)(X4, X5, X6, X7);
2279
2280  static R Run(BindStateBase* base,
2281      typename CallbackParamTraits<X4>::ForwardType x4,
2282      typename CallbackParamTraits<X5>::ForwardType x5,
2283      typename CallbackParamTraits<X6>::ForwardType x6,
2284      typename CallbackParamTraits<X7>::ForwardType x7) {
2285    StorageType* storage = static_cast<StorageType*>(base);
2286
2287    // Local references to make debugger stepping easier. If in a debugger,
2288    // you really want to warp ahead and step through the
2289    // InvokeHelper<>::MakeItSo() call below.
2290    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2291    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2292    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2293
2294    typename Bound1UnwrapTraits::ForwardType x1 =
2295        Bound1UnwrapTraits::Unwrap(storage->p1_);
2296    typename Bound2UnwrapTraits::ForwardType x2 =
2297        Bound2UnwrapTraits::Unwrap(storage->p2_);
2298    typename Bound3UnwrapTraits::ForwardType x3 =
2299        Bound3UnwrapTraits::Unwrap(storage->p3_);
2300    return InvokeHelper<StorageType::IsWeakCall::value, R,
2301           typename StorageType::RunnableType,
2302           void(typename Bound1UnwrapTraits::ForwardType,
2303               typename Bound2UnwrapTraits::ForwardType,
2304               typename Bound3UnwrapTraits::ForwardType,
2305               typename CallbackParamTraits<X4>::ForwardType x4,
2306               typename CallbackParamTraits<X5>::ForwardType x5,
2307               typename CallbackParamTraits<X6>::ForwardType x6,
2308               typename CallbackParamTraits<X7>::ForwardType x7)>
2309               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2310                   CallbackForward(x2), CallbackForward(x3),
2311                   CallbackForward(x4), CallbackForward(x5),
2312                   CallbackForward(x6), CallbackForward(x7));
2313  }
2314};
2315
2316// Arity 7 -> 3.
2317template <typename StorageType, typename R,typename X1, typename X2,
2318    typename X3, typename X4, typename X5, typename X6, typename X7>
2319struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2320  typedef R(RunType)(BindStateBase*,
2321      typename CallbackParamTraits<X5>::ForwardType,
2322      typename CallbackParamTraits<X6>::ForwardType,
2323      typename CallbackParamTraits<X7>::ForwardType);
2324
2325  typedef R(UnboundRunType)(X5, X6, X7);
2326
2327  static R Run(BindStateBase* base,
2328      typename CallbackParamTraits<X5>::ForwardType x5,
2329      typename CallbackParamTraits<X6>::ForwardType x6,
2330      typename CallbackParamTraits<X7>::ForwardType x7) {
2331    StorageType* storage = static_cast<StorageType*>(base);
2332
2333    // Local references to make debugger stepping easier. If in a debugger,
2334    // you really want to warp ahead and step through the
2335    // InvokeHelper<>::MakeItSo() call below.
2336    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2337    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2338    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2339    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2340
2341    typename Bound1UnwrapTraits::ForwardType x1 =
2342        Bound1UnwrapTraits::Unwrap(storage->p1_);
2343    typename Bound2UnwrapTraits::ForwardType x2 =
2344        Bound2UnwrapTraits::Unwrap(storage->p2_);
2345    typename Bound3UnwrapTraits::ForwardType x3 =
2346        Bound3UnwrapTraits::Unwrap(storage->p3_);
2347    typename Bound4UnwrapTraits::ForwardType x4 =
2348        Bound4UnwrapTraits::Unwrap(storage->p4_);
2349    return InvokeHelper<StorageType::IsWeakCall::value, R,
2350           typename StorageType::RunnableType,
2351           void(typename Bound1UnwrapTraits::ForwardType,
2352               typename Bound2UnwrapTraits::ForwardType,
2353               typename Bound3UnwrapTraits::ForwardType,
2354               typename Bound4UnwrapTraits::ForwardType,
2355               typename CallbackParamTraits<X5>::ForwardType x5,
2356               typename CallbackParamTraits<X6>::ForwardType x6,
2357               typename CallbackParamTraits<X7>::ForwardType x7)>
2358               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2359                   CallbackForward(x2), CallbackForward(x3),
2360                   CallbackForward(x4), CallbackForward(x5),
2361                   CallbackForward(x6), CallbackForward(x7));
2362  }
2363};
2364
2365// Arity 7 -> 2.
2366template <typename StorageType, typename R,typename X1, typename X2,
2367    typename X3, typename X4, typename X5, typename X6, typename X7>
2368struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2369  typedef R(RunType)(BindStateBase*,
2370      typename CallbackParamTraits<X6>::ForwardType,
2371      typename CallbackParamTraits<X7>::ForwardType);
2372
2373  typedef R(UnboundRunType)(X6, X7);
2374
2375  static R Run(BindStateBase* base,
2376      typename CallbackParamTraits<X6>::ForwardType x6,
2377      typename CallbackParamTraits<X7>::ForwardType x7) {
2378    StorageType* storage = static_cast<StorageType*>(base);
2379
2380    // Local references to make debugger stepping easier. If in a debugger,
2381    // you really want to warp ahead and step through the
2382    // InvokeHelper<>::MakeItSo() call below.
2383    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2384    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2385    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2386    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2387    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2388
2389    typename Bound1UnwrapTraits::ForwardType x1 =
2390        Bound1UnwrapTraits::Unwrap(storage->p1_);
2391    typename Bound2UnwrapTraits::ForwardType x2 =
2392        Bound2UnwrapTraits::Unwrap(storage->p2_);
2393    typename Bound3UnwrapTraits::ForwardType x3 =
2394        Bound3UnwrapTraits::Unwrap(storage->p3_);
2395    typename Bound4UnwrapTraits::ForwardType x4 =
2396        Bound4UnwrapTraits::Unwrap(storage->p4_);
2397    typename Bound5UnwrapTraits::ForwardType x5 =
2398        Bound5UnwrapTraits::Unwrap(storage->p5_);
2399    return InvokeHelper<StorageType::IsWeakCall::value, R,
2400           typename StorageType::RunnableType,
2401           void(typename Bound1UnwrapTraits::ForwardType,
2402               typename Bound2UnwrapTraits::ForwardType,
2403               typename Bound3UnwrapTraits::ForwardType,
2404               typename Bound4UnwrapTraits::ForwardType,
2405               typename Bound5UnwrapTraits::ForwardType,
2406               typename CallbackParamTraits<X6>::ForwardType x6,
2407               typename CallbackParamTraits<X7>::ForwardType x7)>
2408               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2409                   CallbackForward(x2), CallbackForward(x3),
2410                   CallbackForward(x4), CallbackForward(x5),
2411                   CallbackForward(x6), CallbackForward(x7));
2412  }
2413};
2414
2415// Arity 7 -> 1.
2416template <typename StorageType, typename R,typename X1, typename X2,
2417    typename X3, typename X4, typename X5, typename X6, typename X7>
2418struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2419  typedef R(RunType)(BindStateBase*,
2420      typename CallbackParamTraits<X7>::ForwardType);
2421
2422  typedef R(UnboundRunType)(X7);
2423
2424  static R Run(BindStateBase* base,
2425      typename CallbackParamTraits<X7>::ForwardType x7) {
2426    StorageType* storage = static_cast<StorageType*>(base);
2427
2428    // Local references to make debugger stepping easier. If in a debugger,
2429    // you really want to warp ahead and step through the
2430    // InvokeHelper<>::MakeItSo() call below.
2431    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2432    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2433    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2434    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2435    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2436    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2437
2438    typename Bound1UnwrapTraits::ForwardType x1 =
2439        Bound1UnwrapTraits::Unwrap(storage->p1_);
2440    typename Bound2UnwrapTraits::ForwardType x2 =
2441        Bound2UnwrapTraits::Unwrap(storage->p2_);
2442    typename Bound3UnwrapTraits::ForwardType x3 =
2443        Bound3UnwrapTraits::Unwrap(storage->p3_);
2444    typename Bound4UnwrapTraits::ForwardType x4 =
2445        Bound4UnwrapTraits::Unwrap(storage->p4_);
2446    typename Bound5UnwrapTraits::ForwardType x5 =
2447        Bound5UnwrapTraits::Unwrap(storage->p5_);
2448    typename Bound6UnwrapTraits::ForwardType x6 =
2449        Bound6UnwrapTraits::Unwrap(storage->p6_);
2450    return InvokeHelper<StorageType::IsWeakCall::value, R,
2451           typename StorageType::RunnableType,
2452           void(typename Bound1UnwrapTraits::ForwardType,
2453               typename Bound2UnwrapTraits::ForwardType,
2454               typename Bound3UnwrapTraits::ForwardType,
2455               typename Bound4UnwrapTraits::ForwardType,
2456               typename Bound5UnwrapTraits::ForwardType,
2457               typename Bound6UnwrapTraits::ForwardType,
2458               typename CallbackParamTraits<X7>::ForwardType x7)>
2459               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2460                   CallbackForward(x2), CallbackForward(x3),
2461                   CallbackForward(x4), CallbackForward(x5),
2462                   CallbackForward(x6), CallbackForward(x7));
2463  }
2464};
2465
2466// Arity 7 -> 0.
2467template <typename StorageType, typename R,typename X1, typename X2,
2468    typename X3, typename X4, typename X5, typename X6, typename X7>
2469struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2470  typedef R(RunType)(BindStateBase*);
2471
2472  typedef R(UnboundRunType)();
2473
2474  static R Run(BindStateBase* base) {
2475    StorageType* storage = static_cast<StorageType*>(base);
2476
2477    // Local references to make debugger stepping easier. If in a debugger,
2478    // you really want to warp ahead and step through the
2479    // InvokeHelper<>::MakeItSo() call below.
2480    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2481    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2482    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2483    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2484    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2485    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2486    typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits;
2487
2488    typename Bound1UnwrapTraits::ForwardType x1 =
2489        Bound1UnwrapTraits::Unwrap(storage->p1_);
2490    typename Bound2UnwrapTraits::ForwardType x2 =
2491        Bound2UnwrapTraits::Unwrap(storage->p2_);
2492    typename Bound3UnwrapTraits::ForwardType x3 =
2493        Bound3UnwrapTraits::Unwrap(storage->p3_);
2494    typename Bound4UnwrapTraits::ForwardType x4 =
2495        Bound4UnwrapTraits::Unwrap(storage->p4_);
2496    typename Bound5UnwrapTraits::ForwardType x5 =
2497        Bound5UnwrapTraits::Unwrap(storage->p5_);
2498    typename Bound6UnwrapTraits::ForwardType x6 =
2499        Bound6UnwrapTraits::Unwrap(storage->p6_);
2500    typename Bound7UnwrapTraits::ForwardType x7 =
2501        Bound7UnwrapTraits::Unwrap(storage->p7_);
2502    return InvokeHelper<StorageType::IsWeakCall::value, R,
2503           typename StorageType::RunnableType,
2504           void(typename Bound1UnwrapTraits::ForwardType,
2505               typename Bound2UnwrapTraits::ForwardType,
2506               typename Bound3UnwrapTraits::ForwardType,
2507               typename Bound4UnwrapTraits::ForwardType,
2508               typename Bound5UnwrapTraits::ForwardType,
2509               typename Bound6UnwrapTraits::ForwardType,
2510               typename Bound7UnwrapTraits::ForwardType)>
2511               ::MakeItSo(storage->runnable_, CallbackForward(x1),
2512                   CallbackForward(x2), CallbackForward(x3),
2513                   CallbackForward(x4), CallbackForward(x5),
2514                   CallbackForward(x6), CallbackForward(x7));
2515  }
2516};
2517
2518
2519// BindState<>
2520//
2521// This stores all the state passed into Bind() and is also where most
2522// of the template resolution magic occurs.
2523//
2524// Runnable is the functor we are binding arguments to.
2525// RunType is type of the Run() function that the Invoker<> should use.
2526// Normally, this is the same as the RunType of the Runnable, but it can
2527// be different if an adapter like IgnoreResult() has been used.
2528//
2529// BoundArgsType contains the storage type for all the bound arguments by
2530// (ab)using a function type.
2531template <typename Runnable, typename RunType, typename BoundArgsType>
2532struct BindState;
2533
2534template <typename Runnable, typename RunType>
2535struct BindState<Runnable, RunType, void()> : public BindStateBase {
2536  typedef Runnable RunnableType;
2537  typedef false_type IsWeakCall;
2538  typedef Invoker<0, BindState, RunType> InvokerType;
2539  typedef typename InvokerType::UnboundRunType UnboundRunType;
2540  explicit BindState(const Runnable& runnable)
2541      : runnable_(runnable) {
2542  }
2543
2544  virtual ~BindState() {  }
2545
2546  RunnableType runnable_;
2547};
2548
2549template <typename Runnable, typename RunType, typename P1>
2550struct BindState<Runnable, RunType, void(P1)> : public BindStateBase {
2551  typedef Runnable RunnableType;
2552  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2553  typedef Invoker<1, BindState, RunType> InvokerType;
2554  typedef typename InvokerType::UnboundRunType UnboundRunType;
2555
2556  // Convenience typedefs for bound argument types.
2557  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2558
2559  BindState(const Runnable& runnable, const P1& p1)
2560      : runnable_(runnable),
2561        p1_(p1) {
2562    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2563  }
2564
2565  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2566      P1>::Release(p1_);  }
2567
2568  RunnableType runnable_;
2569  P1 p1_;
2570};
2571
2572template <typename Runnable, typename RunType, typename P1, typename P2>
2573struct BindState<Runnable, RunType, void(P1, P2)> : public BindStateBase {
2574  typedef Runnable RunnableType;
2575  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2576  typedef Invoker<2, BindState, RunType> InvokerType;
2577  typedef typename InvokerType::UnboundRunType UnboundRunType;
2578
2579  // Convenience typedefs for bound argument types.
2580  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2581  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2582
2583  BindState(const Runnable& runnable, const P1& p1, const P2& p2)
2584      : runnable_(runnable),
2585        p1_(p1),
2586        p2_(p2) {
2587    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2588  }
2589
2590  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2591      P1>::Release(p1_);  }
2592
2593  RunnableType runnable_;
2594  P1 p1_;
2595  P2 p2_;
2596};
2597
2598template <typename Runnable, typename RunType, typename P1, typename P2,
2599    typename P3>
2600struct BindState<Runnable, RunType, void(P1, P2, P3)> : public BindStateBase {
2601  typedef Runnable RunnableType;
2602  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2603  typedef Invoker<3, BindState, RunType> InvokerType;
2604  typedef typename InvokerType::UnboundRunType UnboundRunType;
2605
2606  // Convenience typedefs for bound argument types.
2607  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2608  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2609  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2610
2611  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3)
2612      : runnable_(runnable),
2613        p1_(p1),
2614        p2_(p2),
2615        p3_(p3) {
2616    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2617  }
2618
2619  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2620      P1>::Release(p1_);  }
2621
2622  RunnableType runnable_;
2623  P1 p1_;
2624  P2 p2_;
2625  P3 p3_;
2626};
2627
2628template <typename Runnable, typename RunType, typename P1, typename P2,
2629    typename P3, typename P4>
2630struct BindState<Runnable, RunType, void(P1, P2, P3,
2631    P4)> : public BindStateBase {
2632  typedef Runnable RunnableType;
2633  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2634  typedef Invoker<4, BindState, RunType> InvokerType;
2635  typedef typename InvokerType::UnboundRunType UnboundRunType;
2636
2637  // Convenience typedefs for bound argument types.
2638  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2639  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2640  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2641  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2642
2643  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2644      const P4& p4)
2645      : runnable_(runnable),
2646        p1_(p1),
2647        p2_(p2),
2648        p3_(p3),
2649        p4_(p4) {
2650    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2651  }
2652
2653  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2654      P1>::Release(p1_);  }
2655
2656  RunnableType runnable_;
2657  P1 p1_;
2658  P2 p2_;
2659  P3 p3_;
2660  P4 p4_;
2661};
2662
2663template <typename Runnable, typename RunType, typename P1, typename P2,
2664    typename P3, typename P4, typename P5>
2665struct BindState<Runnable, RunType, void(P1, P2, P3, P4,
2666    P5)> : public BindStateBase {
2667  typedef Runnable RunnableType;
2668  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2669  typedef Invoker<5, BindState, RunType> InvokerType;
2670  typedef typename InvokerType::UnboundRunType UnboundRunType;
2671
2672  // Convenience typedefs for bound argument types.
2673  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2674  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2675  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2676  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2677  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2678
2679  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2680      const P4& p4, const P5& p5)
2681      : runnable_(runnable),
2682        p1_(p1),
2683        p2_(p2),
2684        p3_(p3),
2685        p4_(p4),
2686        p5_(p5) {
2687    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2688  }
2689
2690  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2691      P1>::Release(p1_);  }
2692
2693  RunnableType runnable_;
2694  P1 p1_;
2695  P2 p2_;
2696  P3 p3_;
2697  P4 p4_;
2698  P5 p5_;
2699};
2700
2701template <typename Runnable, typename RunType, typename P1, typename P2,
2702    typename P3, typename P4, typename P5, typename P6>
2703struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5,
2704    P6)> : public BindStateBase {
2705  typedef Runnable RunnableType;
2706  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2707  typedef Invoker<6, BindState, RunType> InvokerType;
2708  typedef typename InvokerType::UnboundRunType UnboundRunType;
2709
2710  // Convenience typedefs for bound argument types.
2711  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2712  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2713  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2714  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2715  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2716  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
2717
2718  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2719      const P4& p4, const P5& p5, const P6& p6)
2720      : runnable_(runnable),
2721        p1_(p1),
2722        p2_(p2),
2723        p3_(p3),
2724        p4_(p4),
2725        p5_(p5),
2726        p6_(p6) {
2727    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2728  }
2729
2730  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2731      P1>::Release(p1_);  }
2732
2733  RunnableType runnable_;
2734  P1 p1_;
2735  P2 p2_;
2736  P3 p3_;
2737  P4 p4_;
2738  P5 p5_;
2739  P6 p6_;
2740};
2741
2742template <typename Runnable, typename RunType, typename P1, typename P2,
2743    typename P3, typename P4, typename P5, typename P6, typename P7>
2744struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6,
2745    P7)> : public BindStateBase {
2746  typedef Runnable RunnableType;
2747  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2748  typedef Invoker<7, BindState, RunType> InvokerType;
2749  typedef typename InvokerType::UnboundRunType UnboundRunType;
2750
2751  // Convenience typedefs for bound argument types.
2752  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2753  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2754  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2755  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2756  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2757  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
2758  typedef UnwrapTraits<P7> Bound7UnwrapTraits;
2759
2760  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2761      const P4& p4, const P5& p5, const P6& p6, const P7& p7)
2762      : runnable_(runnable),
2763        p1_(p1),
2764        p2_(p2),
2765        p3_(p3),
2766        p4_(p4),
2767        p5_(p5),
2768        p6_(p6),
2769        p7_(p7) {
2770    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2771  }
2772
2773  virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2774      P1>::Release(p1_);  }
2775
2776  RunnableType runnable_;
2777  P1 p1_;
2778  P2 p2_;
2779  P3 p3_;
2780  P4 p4_;
2781  P5 p5_;
2782  P6 p6_;
2783  P7 p7_;
2784};
2785
2786}  // namespace internal
2787}  // namespace base
2788
2789#endif  // BASE_BIND_INTERNAL_H_
2790