base/bind_internal.h

   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
  24 namespace base {
  25 namespace 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
 101 template <typename Functor>
 102 class RunnableAdapter;
 103
 104 // Function: Arity 0.
 105 template <typename R>
 106 class 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.
 123 template <typename R, typename T>
 124 class 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.
 142 template <typename R, typename T>
 143 class 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.
 161 template <typename R, typename A1>
 162 class 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.
 179 template <typename R, typename T, typename A1>
 180 class 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.
 198 template <typename R, typename T, typename A1>
 199 class 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.
 217 template <typename R, typename A1, typename A2>
 218 class 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.
 236 template <typename R, typename T, typename A1, typename A2>
 237 class 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.
 256 template <typename R, typename T, typename A1, typename A2>
 257 class 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.
 276 template <typename R, typename A1, typename A2, typename A3>
 277 class 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.
 297 template <typename R, typename T, typename A1, typename A2, typename A3>
 298 class 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.
 319 template <typename R, typename T, typename A1, typename A2, typename A3>
 320 class 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.
 341 template <typename R, typename A1, typename A2, typename A3, typename A4>
 342 class 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.
 363 template <typename R, typename T, typename A1, typename A2, typename A3,
 364     typename A4>
 365 class 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.
 387 template <typename R, typename T, typename A1, typename A2, typename A3,
 388     typename A4>
 389 class 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.
 411 template <typename R, typename A1, typename A2, typename A3, typename A4,
 412     typename A5>
 413 class 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.
 435 template <typename R, typename T, typename A1, typename A2, typename A3,
 436     typename A4, typename A5>
 437 class 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.
 460 template <typename R, typename T, typename A1, typename A2, typename A3,
 461     typename A4, typename A5>
 462 class 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.
 485 template <typename R, typename A1, typename A2, typename A3, typename A4,
 486     typename A5, typename A6>
 487 class 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.
 511 template <typename R, typename T, typename A1, typename A2, typename A3,
 512     typename A4, typename A5, typename A6>
 513 class 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.
 538 template <typename R, typename T, typename A1, typename A2, typename A3,
 539     typename A4, typename A5, typename A6>
 540 class 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.
 565 template <typename R, typename A1, typename A2, typename A3, typename A4,
 566     typename A5, typename A6, typename A7>
 567 class 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.
 592 template <typename R, typename T, typename A1, typename A2, typename A3,
 593     typename A4, typename A5, typename A6, typename A7>
 594 class 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.
 620 template <typename R, typename T, typename A1, typename A2, typename A3,
 621     typename A4, typename A5, typename A6, typename A7>
 622 class 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.
 651 template <typename Sig>
 652 struct FunctionTraits;
 653
 654 template <typename R>
 655 struct FunctionTraits<R()> {
 656   typedef R ReturnType;
 657 };
 658
 659 template <typename R, typename A1>
 660 struct FunctionTraits<R(A1)> {
 661   typedef R ReturnType;
 662   typedef A1 A1Type;
 663 };
 664
 665 template <typename R, typename A1, typename A2>
 666 struct FunctionTraits<R(A1, A2)> {
 667   typedef R ReturnType;
 668   typedef A1 A1Type;
 669   typedef A2 A2Type;
 670 };
 671
 672 template <typename R, typename A1, typename A2, typename A3>
 673 struct FunctionTraits<R(A1, A2, A3)> {
 674   typedef R ReturnType;
 675   typedef A1 A1Type;
 676   typedef A2 A2Type;
 677   typedef A3 A3Type;
 678 };
 679
 680 template <typename R, typename A1, typename A2, typename A3, typename A4>
 681 struct 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
 689 template <typename R, typename A1, typename A2, typename A3, typename A4,
 690     typename A5>
 691 struct 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
 700 template <typename R, typename A1, typename A2, typename A3, typename A4,
 701     typename A5, typename A6>
 702 struct 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
 712 template <typename R, typename A1, typename A2, typename A3, typename A4,
 713     typename A5, typename A6, typename A7>
 714 struct 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.
 729 template <typename Sig>
 730 struct ForceVoidReturn;
 731
 732 template <typename R>
 733 struct ForceVoidReturn<R()> {
 734   typedef void(RunType)();
 735 };
 736
 737 template <typename R, typename A1>
 738 struct ForceVoidReturn<R(A1)> {
 739   typedef void(RunType)(A1);
 740 };
 741
 742 template <typename R, typename A1, typename A2>
 743 struct ForceVoidReturn<R(A1, A2)> {
 744   typedef void(RunType)(A1, A2);
 745 };
 746
 747 template <typename R, typename A1, typename A2, typename A3>
 748 struct ForceVoidReturn<R(A1, A2, A3)> {
 749   typedef void(RunType)(A1, A2, A3);
 750 };
 751
 752 template <typename R, typename A1, typename A2, typename A3, typename A4>
 753 struct ForceVoidReturn<R(A1, A2, A3, A4)> {
 754   typedef void(RunType)(A1, A2, A3, A4);
 755 };
 756
 757 template <typename R, typename A1, typename A2, typename A3, typename A4,
 758     typename A5>
 759 struct ForceVoidReturn<R(A1, A2, A3, A4, A5)> {
 760   typedef void(RunType)(A1, A2, A3, A4, A5);
 761 };
 762
 763 template <typename R, typename A1, typename A2, typename A3, typename A4,
 764     typename A5, typename A6>
 765 struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6)> {
 766   typedef void(RunType)(A1, A2, A3, A4, A5, A6);
 767 };
 768
 769 template <typename R, typename A1, typename A2, typename A3, typename A4,
 770     typename A5, typename A6, typename A7>
 771 struct 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.
 779 template <typename T>
 780 struct FunctorTraits {
 781   typedef RunnableAdapter<T> RunnableType;
 782   typedef typename RunnableType::RunType RunType;
 783 };
 784
 785 template <typename T>
 786 struct FunctorTraits<IgnoreResultHelper<T> > {
 787   typedef typename FunctorTraits<T>::RunnableType RunnableType;
 788   typedef typename ForceVoidReturn<
 789       typename RunnableType::RunType>::RunType RunType;
 790 };
 791
 792 template <typename T>
 793 struct 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
 803 template <typename T>
 804 typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
 805   return RunnableAdapter<T>(t);
 806 }
 807
 808 template <typename T>
 809 typename FunctorTraits<T>::RunnableType
 810 MakeRunnable(const IgnoreResultHelper<T>& t) {
 811   return MakeRunnable(t.functor_);
 812 }
 813
 814 template <typename T>
 815 const typename FunctorTraits<Callback<T> >::RunnableType&
 816 MakeRunnable(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.
 839 template <bool IsWeakCall, typename ReturnType, typename Runnable,
 840           typename ArgsType>
 841 struct InvokeHelper;
 842
 843 template <typename ReturnType, typename Runnable>
 844 struct InvokeHelper<false, ReturnType, Runnable,
 845     void()>  {
 846   static ReturnType MakeItSo(Runnable runnable) {
 847     return runnable.Run();
 848   }
 849 };
 850
 851 template <typename Runnable>
 852 struct InvokeHelper<false, void, Runnable,
 853     void()>  {
 854   static void MakeItSo(Runnable runnable) {
 855     runnable.Run();
 856   }
 857 };
 858
 859 template <typename ReturnType, typename Runnable,typename A1>
 860 struct InvokeHelper<false, ReturnType, Runnable,
 861     void(A1)>  {
 862   static ReturnType MakeItSo(Runnable runnable, A1 a1) {
 863     return runnable.Run(CallbackForward(a1));
 864   }
 865 };
 866
 867 template <typename Runnable,typename A1>
 868 struct InvokeHelper<false, void, Runnable,
 869     void(A1)>  {
 870   static void MakeItSo(Runnable runnable, A1 a1) {
 871     runnable.Run(CallbackForward(a1));
 872   }
 873 };
 874
 875 template <typename Runnable, typename BoundWeakPtr>
 876 struct 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
 886 template <typename ReturnType, typename Runnable,typename A1, typename A2>
 887 struct 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
 894 template <typename Runnable,typename A1, typename A2>
 895 struct 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
 902 template <typename Runnable, typename BoundWeakPtr, typename A2>
 903 struct 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
 913 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 914     typename A3>
 915 struct 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
 923 template <typename Runnable,typename A1, typename A2, typename A3>
 924 struct 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
 931 template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3>
 932 struct 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
 942 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 943     typename A3, typename A4>
 944 struct 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
 952 template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
 953 struct 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
 961 template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
 962     typename A4>
 963 struct 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
 975 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 976     typename A3, typename A4, typename A5>
 977 struct 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
 986 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
 987     typename A5>
 988 struct 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
 996 template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
 997     typename A4, typename A5>
 998 struct 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
1010 template <typename ReturnType, typename Runnable,typename A1, typename A2,
1011     typename A3, typename A4, typename A5, typename A6>
1012 struct 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
1022 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1023     typename A5, typename A6>
1024 struct 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
1033 template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
1034     typename A4, typename A5, typename A6>
1035 struct 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
1047 template <typename ReturnType, typename Runnable,typename A1, typename A2,
1048     typename A3, typename A4, typename A5, typename A6, typename A7>
1049 struct 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
1059 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1060     typename A5, typename A6, typename A7>
1061 struct 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
1071 template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
1072     typename A4, typename A5, typename A6, typename A7>
1073 struct 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
1088 template <typename ReturnType, typename Runnable, typename ArgsType>
1089 struct 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.
1102 template <int NumBound, typename Storage, typename RunType>
1103 struct Invoker;
1104
1105 // Arity 0 -> 0.
1106 template <typename StorageType, typename R>
1107 struct 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.
1127 template <typename StorageType, typename R,typename X1>
1128 struct 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.
1150 template <typename StorageType, typename R,typename X1>
1151 struct 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.
1174 template <typename StorageType, typename R,typename X1, typename X2>
1175 struct 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.
1201 template <typename StorageType, typename R,typename X1, typename X2>
1202 struct 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.
1229 template <typename StorageType, typename R,typename X1, typename X2>
1230 struct 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.
1258 template <typename StorageType, typename R,typename X1, typename X2,
1259     typename X3>
1260 struct 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.
1289 template <typename StorageType, typename R,typename X1, typename X2,
1290     typename X3>
1291 struct 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.
1321 template <typename StorageType, typename R,typename X1, typename X2,
1322     typename X3>
1323 struct 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.
1354 template <typename StorageType, typename R,typename X1, typename X2,
1355     typename X3>
1356 struct 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.
1388 template <typename StorageType, typename R,typename X1, typename X2,
1389     typename X3, typename X4>
1390 struct 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.
1423 template <typename StorageType, typename R,typename X1, typename X2,
1424     typename X3, typename X4>
1425 struct 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.
1459 template <typename StorageType, typename R,typename X1, typename X2,
1460     typename X3, typename X4>
1461 struct 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.
1496 template <typename StorageType, typename R,typename X1, typename X2,
1497     typename X3, typename X4>
1498 struct 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.
1534 template <typename StorageType, typename R,typename X1, typename X2,
1535     typename X3, typename X4>
1536 struct 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.
1573 template <typename StorageType, typename R,typename X1, typename X2,
1574     typename X3, typename X4, typename X5>
1575 struct 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.
1611 template <typename StorageType, typename R,typename X1, typename X2,
1612     typename X3, typename X4, typename X5>
1613 struct 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.
1650 template <typename StorageType, typename R,typename X1, typename X2,
1651     typename X3, typename X4, typename X5>
1652 struct 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.
1690 template <typename StorageType, typename R,typename X1, typename X2,
1691     typename X3, typename X4, typename X5>
1692 struct 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.
1731 template <typename StorageType, typename R,typename X1, typename X2,
1732     typename X3, typename X4, typename X5>
1733 struct 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.
1773 template <typename StorageType, typename R,typename X1, typename X2,
1774     typename X3, typename X4, typename X5>
1775 struct 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.
1816 template <typename StorageType, typename R,typename X1, typename X2,
1817     typename X3, typename X4, typename X5, typename X6>
1818 struct 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.
1858 template <typename StorageType, typename R,typename X1, typename X2,
1859     typename X3, typename X4, typename X5, typename X6>
1860 struct 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.
1901 template <typename StorageType, typename R,typename X1, typename X2,
1902     typename X3, typename X4, typename X5, typename X6>
1903 struct 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.
1945 template <typename StorageType, typename R,typename X1, typename X2,
1946     typename X3, typename X4, typename X5, typename X6>
1947 struct 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.
1990 template <typename StorageType, typename R,typename X1, typename X2,
1991     typename X3, typename X4, typename X5, typename X6>
1992 struct 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.
2036 template <typename StorageType, typename R,typename X1, typename X2,
2037     typename X3, typename X4, typename X5, typename X6>
2038 struct 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.
2083 template <typename StorageType, typename R,typename X1, typename X2,
2084     typename X3, typename X4, typename X5, typename X6>
2085 struct 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.
2131 template <typename StorageType, typename R,typename X1, typename X2,
2132     typename X3, typename X4, typename X5, typename X6, typename X7>
2133 struct 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.
2176 template <typename StorageType, typename R,typename X1, typename X2,
2177     typename X3, typename X4, typename X5, typename X6, typename X7>
2178 struct 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.
2222 template <typename StorageType, typename R,typename X1, typename X2,
2223     typename X3, typename X4, typename X5, typename X6, typename X7>
2224 struct 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.
2269 template <typename StorageType, typename R,typename X1, typename X2,
2270     typename X3, typename X4, typename X5, typename X6, typename X7>
2271 struct 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.
2317 template <typename StorageType, typename R,typename X1, typename X2,
2318     typename X3, typename X4, typename X5, typename X6, typename X7>
2319 struct 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.
2366 template <typename StorageType, typename R,typename X1, typename X2,
2367     typename X3, typename X4, typename X5, typename X6, typename X7>
2368 struct 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.
2416 template <typename StorageType, typename R,typename X1, typename X2,
2417     typename X3, typename X4, typename X5, typename X6, typename X7>
2418 struct 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.
2467 template <typename StorageType, typename R,typename X1, typename X2,
2468     typename X3, typename X4, typename X5, typename X6, typename X7>
2469 struct 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.
2531 template <typename Runnable, typename RunType, typename BoundArgsType>
2532 struct BindState;
2533
2534 template <typename Runnable, typename RunType>
2535 struct 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
2549 template <typename Runnable, typename RunType, typename P1>
2550 struct 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
2572 template <typename Runnable, typename RunType, typename P1, typename P2>
2573 struct 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
2598 template <typename Runnable, typename RunType, typename P1, typename P2,
2599     typename P3>
2600 struct 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
2628 template <typename Runnable, typename RunType, typename P1, typename P2,
2629     typename P3, typename P4>
2630 struct 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
2663 template <typename Runnable, typename RunType, typename P1, typename P2,
2664     typename P3, typename P4, typename P5>
2665 struct 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
2701 template <typename Runnable, typename RunType, typename P1, typename P2,
2702     typename P3, typename P4, typename P5, typename P6>
2703 struct 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
2742 template <typename Runnable, typename RunType, typename P1, typename P2,
2743     typename P3, typename P4, typename P5, typename P6, typename P7>
2744 struct 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_