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   return t;
 818 }
 819
 820
 821 // InvokeHelper<>
 822 //
 823 // There are 3 logical InvokeHelper<> specializations: normal, void-return,
 824 // WeakCalls.
 825 //
 826 // The normal type just calls the underlying runnable.
 827 //
 828 // We need a InvokeHelper to handle void return types in order to support
 829 // IgnoreResult().  Normally, if the Runnable's RunType had a void return,
 830 // the template system would just accept "return functor.Run()" ignoring
 831 // the fact that a void function is being used with return. This piece of
 832 // sugar breaks though when the Runnable's RunType is not void.  Thus, we
 833 // need a partial specialization to change the syntax to drop the "return"
 834 // from the invocation call.
 835 //
 836 // WeakCalls similarly need special syntax that is applied to the first
 837 // argument to check if they should no-op themselves.
 838 template <bool IsWeakCall, typename ReturnType, typename Runnable,
 839           typename ArgsType>
 840 struct InvokeHelper;
 841
 842 template <typename ReturnType, typename Runnable>
 843 struct InvokeHelper<false, ReturnType, Runnable,
 844     void()>  {
 845   static ReturnType MakeItSo(Runnable runnable) {
 846     return runnable.Run();
 847   }
 848 };
 849
 850 template <typename Runnable>
 851 struct InvokeHelper<false, void, Runnable,
 852     void()>  {
 853   static void MakeItSo(Runnable runnable) {
 854     runnable.Run();
 855   }
 856 };
 857
 858 template <typename ReturnType, typename Runnable,typename A1>
 859 struct InvokeHelper<false, ReturnType, Runnable,
 860     void(A1)>  {
 861   static ReturnType MakeItSo(Runnable runnable, A1 a1) {
 862     return runnable.Run(CallbackForward(a1));
 863   }
 864 };
 865
 866 template <typename Runnable,typename A1>
 867 struct InvokeHelper<false, void, Runnable,
 868     void(A1)>  {
 869   static void MakeItSo(Runnable runnable, A1 a1) {
 870     runnable.Run(CallbackForward(a1));
 871   }
 872 };
 873
 874 template <typename Runnable, typename A1>
 875 struct InvokeHelper<true, void, Runnable,
 876     void(A1)>  {
 877   static void MakeItSo(Runnable runnable, A1 a1) {
 878     if (!a1.get()) {
 879       return;
 880     }
 881
 882     runnable.Run(CallbackForward(a1));
 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 A1, typename A2>
 903 struct InvokeHelper<true, void, Runnable,
 904     void(A1, A2)>  {
 905   static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
 906     if (!a1.get()) {
 907       return;
 908     }
 909
 910     runnable.Run(CallbackForward(a1), CallbackForward(a2));
 911   }
 912 };
 913
 914 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 915     typename A3>
 916 struct InvokeHelper<false, ReturnType, Runnable,
 917     void(A1, A2, A3)>  {
 918   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
 919     return runnable.Run(CallbackForward(a1), CallbackForward(a2),
 920         CallbackForward(a3));
 921   }
 922 };
 923
 924 template <typename Runnable,typename A1, typename A2, typename A3>
 925 struct InvokeHelper<false, void, Runnable,
 926     void(A1, A2, A3)>  {
 927   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
 928     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
 929   }
 930 };
 931
 932 template <typename Runnable, typename A1, typename A2, typename A3>
 933 struct InvokeHelper<true, void, Runnable,
 934     void(A1, A2, A3)>  {
 935   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
 936     if (!a1.get()) {
 937       return;
 938     }
 939
 940     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
 941   }
 942 };
 943
 944 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 945     typename A3, typename A4>
 946 struct InvokeHelper<false, ReturnType, Runnable,
 947     void(A1, A2, A3, A4)>  {
 948   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
 949     return runnable.Run(CallbackForward(a1), CallbackForward(a2),
 950         CallbackForward(a3), CallbackForward(a4));
 951   }
 952 };
 953
 954 template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
 955 struct InvokeHelper<false, void, Runnable,
 956     void(A1, A2, A3, A4)>  {
 957   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
 958     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
 959         CallbackForward(a4));
 960   }
 961 };
 962
 963 template <typename Runnable, typename A1, typename A2, typename A3, typename A4>
 964 struct InvokeHelper<true, void, Runnable,
 965     void(A1, A2, A3, A4)>  {
 966   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
 967     if (!a1.get()) {
 968       return;
 969     }
 970
 971     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
 972         CallbackForward(a4));
 973   }
 974 };
 975
 976 template <typename ReturnType, typename Runnable,typename A1, typename A2,
 977     typename A3, typename A4, typename A5>
 978 struct InvokeHelper<false, ReturnType, Runnable,
 979     void(A1, A2, A3, A4, A5)>  {
 980   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
 981       A5 a5) {
 982     return runnable.Run(CallbackForward(a1), CallbackForward(a2),
 983         CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
 984   }
 985 };
 986
 987 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
 988     typename A5>
 989 struct InvokeHelper<false, void, Runnable,
 990     void(A1, A2, A3, A4, A5)>  {
 991   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
 992     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
 993         CallbackForward(a4), CallbackForward(a5));
 994   }
 995 };
 996
 997 template <typename Runnable, typename A1, typename A2, typename A3,
 998     typename A4, typename A5>
 999 struct InvokeHelper<true, void, Runnable,
1000     void(A1, A2, A3, A4, A5)>  {
1001   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
1002     if (!a1.get()) {
1003       return;
1004     }
1005
1006     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1007         CallbackForward(a4), CallbackForward(a5));
1008   }
1009 };
1010
1011 template <typename ReturnType, typename Runnable,typename A1, typename A2,
1012     typename A3, typename A4, typename A5, typename A6>
1013 struct InvokeHelper<false, ReturnType, Runnable,
1014     void(A1, A2, A3, A4, A5, A6)>  {
1015   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
1016       A5 a5, A6 a6) {
1017     return runnable.Run(CallbackForward(a1), CallbackForward(a2),
1018         CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
1019         CallbackForward(a6));
1020   }
1021 };
1022
1023 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1024     typename A5, typename A6>
1025 struct InvokeHelper<false, void, Runnable,
1026     void(A1, A2, A3, A4, A5, A6)>  {
1027   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1028       A6 a6) {
1029     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1030         CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
1031   }
1032 };
1033
1034 template <typename Runnable, typename A1, typename A2, typename A3,
1035     typename A4, typename A5, typename A6>
1036 struct InvokeHelper<true, void, Runnable,
1037     void(A1, A2, A3, A4, A5, A6)>  {
1038   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1039       A6 a6) {
1040     if (!a1.get()) {
1041       return;
1042     }
1043
1044     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1045         CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
1046   }
1047 };
1048
1049 template <typename ReturnType, typename Runnable,typename A1, typename A2,
1050     typename A3, typename A4, typename A5, typename A6, typename A7>
1051 struct InvokeHelper<false, ReturnType, Runnable,
1052     void(A1, A2, A3, A4, A5, A6, A7)>  {
1053   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
1054       A5 a5, A6 a6, A7 a7) {
1055     return runnable.Run(CallbackForward(a1), CallbackForward(a2),
1056         CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
1057         CallbackForward(a6), CallbackForward(a7));
1058   }
1059 };
1060
1061 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
1062     typename A5, typename A6, typename A7>
1063 struct InvokeHelper<false, void, Runnable,
1064     void(A1, A2, A3, A4, A5, A6, A7)>  {
1065   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1066       A6 a6, A7 a7) {
1067     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1068         CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
1069         CallbackForward(a7));
1070   }
1071 };
1072
1073 template <typename Runnable, typename A1, typename A2, typename A3,
1074     typename A4, typename A5, typename A6, typename A7>
1075 struct InvokeHelper<true, void, Runnable,
1076     void(A1, A2, A3, A4, A5, A6, A7)>  {
1077   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
1078       A6 a6, A7 a7) {
1079     if (!a1.get()) {
1080       return;
1081     }
1082
1083     runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
1084         CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
1085         CallbackForward(a7));
1086   }
1087 };
1088
1089 #if !defined(_MSC_VER)
1090
1091 template <typename ReturnType, typename Runnable, typename ArgsType>
1092 struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
1093   // WeakCalls are only supported for functions with a void return type.
1094   // Otherwise, the function result would be undefined if the the WeakPtr<>
1095   // is invalidated.
1096   COMPILE_ASSERT(is_void<ReturnType>::value,
1097                  weak_ptrs_can_only_bind_to_methods_without_return_values);
1098 };
1099
1100 #endif
1101
1102 // Invoker<>
1103 //
1104 // See description at the top of the file.
1105 template <int NumBound, typename Storage, typename RunType>
1106 struct Invoker;
1107
1108 // Arity 0 -> 0.
1109 template <typename StorageType, typename R>
1110 struct Invoker<0, StorageType, R()> {
1111   typedef R(RunType)(BindStateBase*);
1112
1113   typedef R(UnboundRunType)();
1114
1115   static R Run(BindStateBase* base) {
1116     StorageType* storage = static_cast<StorageType*>(base);
1117
1118     // Local references to make debugger stepping easier. If in a debugger,
1119     // you really want to warp ahead and step through the
1120     // InvokeHelper<>::MakeItSo() call below.
1121
1122     return InvokeHelper<StorageType::IsWeakCall::value, R,
1123            typename StorageType::RunnableType,
1124            void()>
1125                ::MakeItSo(storage->runnable_);
1126   }
1127 };
1128
1129 // Arity 1 -> 1.
1130 template <typename StorageType, typename R,typename X1>
1131 struct Invoker<0, StorageType, R(X1)> {
1132   typedef R(RunType)(BindStateBase*,
1133       typename CallbackParamTraits<X1>::ForwardType);
1134
1135   typedef R(UnboundRunType)(X1);
1136
1137   static R Run(BindStateBase* base,
1138       typename CallbackParamTraits<X1>::ForwardType x1) {
1139     StorageType* storage = static_cast<StorageType*>(base);
1140
1141     // Local references to make debugger stepping easier. If in a debugger,
1142     // you really want to warp ahead and step through the
1143     // InvokeHelper<>::MakeItSo() call below.
1144
1145     return InvokeHelper<StorageType::IsWeakCall::value, R,
1146            typename StorageType::RunnableType,
1147            void(typename CallbackParamTraits<X1>::ForwardType x1)>
1148                ::MakeItSo(storage->runnable_, CallbackForward(x1));
1149   }
1150 };
1151
1152 // Arity 1 -> 0.
1153 template <typename StorageType, typename R,typename X1>
1154 struct Invoker<1, StorageType, R(X1)> {
1155   typedef R(RunType)(BindStateBase*);
1156
1157   typedef R(UnboundRunType)();
1158
1159   static R Run(BindStateBase* base) {
1160     StorageType* storage = static_cast<StorageType*>(base);
1161
1162     // Local references to make debugger stepping easier. If in a debugger,
1163     // you really want to warp ahead and step through the
1164     // InvokeHelper<>::MakeItSo() call below.
1165     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1166
1167     typename Bound1UnwrapTraits::ForwardType x1 =
1168         Bound1UnwrapTraits::Unwrap(storage->p1_);
1169     return InvokeHelper<StorageType::IsWeakCall::value, R,
1170            typename StorageType::RunnableType,
1171            void(typename Bound1UnwrapTraits::ForwardType)>
1172                ::MakeItSo(storage->runnable_, CallbackForward(x1));
1173   }
1174 };
1175
1176 // Arity 2 -> 2.
1177 template <typename StorageType, typename R,typename X1, typename X2>
1178 struct Invoker<0, StorageType, R(X1, X2)> {
1179   typedef R(RunType)(BindStateBase*,
1180       typename CallbackParamTraits<X1>::ForwardType,
1181       typename CallbackParamTraits<X2>::ForwardType);
1182
1183   typedef R(UnboundRunType)(X1, X2);
1184
1185   static R Run(BindStateBase* base,
1186       typename CallbackParamTraits<X1>::ForwardType x1,
1187       typename CallbackParamTraits<X2>::ForwardType x2) {
1188     StorageType* storage = static_cast<StorageType*>(base);
1189
1190     // Local references to make debugger stepping easier. If in a debugger,
1191     // you really want to warp ahead and step through the
1192     // InvokeHelper<>::MakeItSo() call below.
1193
1194     return InvokeHelper<StorageType::IsWeakCall::value, R,
1195            typename StorageType::RunnableType,
1196            void(typename CallbackParamTraits<X1>::ForwardType x1,
1197                typename CallbackParamTraits<X2>::ForwardType x2)>
1198                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1199                    CallbackForward(x2));
1200   }
1201 };
1202
1203 // Arity 2 -> 1.
1204 template <typename StorageType, typename R,typename X1, typename X2>
1205 struct Invoker<1, StorageType, R(X1, X2)> {
1206   typedef R(RunType)(BindStateBase*,
1207       typename CallbackParamTraits<X2>::ForwardType);
1208
1209   typedef R(UnboundRunType)(X2);
1210
1211   static R Run(BindStateBase* base,
1212       typename CallbackParamTraits<X2>::ForwardType x2) {
1213     StorageType* storage = static_cast<StorageType*>(base);
1214
1215     // Local references to make debugger stepping easier. If in a debugger,
1216     // you really want to warp ahead and step through the
1217     // InvokeHelper<>::MakeItSo() call below.
1218     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1219
1220     typename Bound1UnwrapTraits::ForwardType x1 =
1221         Bound1UnwrapTraits::Unwrap(storage->p1_);
1222     return InvokeHelper<StorageType::IsWeakCall::value, R,
1223            typename StorageType::RunnableType,
1224            void(typename Bound1UnwrapTraits::ForwardType,
1225                typename CallbackParamTraits<X2>::ForwardType x2)>
1226                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1227                    CallbackForward(x2));
1228   }
1229 };
1230
1231 // Arity 2 -> 0.
1232 template <typename StorageType, typename R,typename X1, typename X2>
1233 struct Invoker<2, StorageType, R(X1, X2)> {
1234   typedef R(RunType)(BindStateBase*);
1235
1236   typedef R(UnboundRunType)();
1237
1238   static R Run(BindStateBase* base) {
1239     StorageType* storage = static_cast<StorageType*>(base);
1240
1241     // Local references to make debugger stepping easier. If in a debugger,
1242     // you really want to warp ahead and step through the
1243     // InvokeHelper<>::MakeItSo() call below.
1244     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1245     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1246
1247     typename Bound1UnwrapTraits::ForwardType x1 =
1248         Bound1UnwrapTraits::Unwrap(storage->p1_);
1249     typename Bound2UnwrapTraits::ForwardType x2 =
1250         Bound2UnwrapTraits::Unwrap(storage->p2_);
1251     return InvokeHelper<StorageType::IsWeakCall::value, R,
1252            typename StorageType::RunnableType,
1253            void(typename Bound1UnwrapTraits::ForwardType,
1254                typename Bound2UnwrapTraits::ForwardType)>
1255                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1256                    CallbackForward(x2));
1257   }
1258 };
1259
1260 // Arity 3 -> 3.
1261 template <typename StorageType, typename R,typename X1, typename X2,
1262     typename X3>
1263 struct Invoker<0, StorageType, R(X1, X2, X3)> {
1264   typedef R(RunType)(BindStateBase*,
1265       typename CallbackParamTraits<X1>::ForwardType,
1266       typename CallbackParamTraits<X2>::ForwardType,
1267       typename CallbackParamTraits<X3>::ForwardType);
1268
1269   typedef R(UnboundRunType)(X1, X2, X3);
1270
1271   static R Run(BindStateBase* base,
1272       typename CallbackParamTraits<X1>::ForwardType x1,
1273       typename CallbackParamTraits<X2>::ForwardType x2,
1274       typename CallbackParamTraits<X3>::ForwardType x3) {
1275     StorageType* storage = static_cast<StorageType*>(base);
1276
1277     // Local references to make debugger stepping easier. If in a debugger,
1278     // you really want to warp ahead and step through the
1279     // InvokeHelper<>::MakeItSo() call below.
1280
1281     return InvokeHelper<StorageType::IsWeakCall::value, R,
1282            typename StorageType::RunnableType,
1283            void(typename CallbackParamTraits<X1>::ForwardType x1,
1284                typename CallbackParamTraits<X2>::ForwardType x2,
1285                typename CallbackParamTraits<X3>::ForwardType x3)>
1286                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1287                    CallbackForward(x2), CallbackForward(x3));
1288   }
1289 };
1290
1291 // Arity 3 -> 2.
1292 template <typename StorageType, typename R,typename X1, typename X2,
1293     typename X3>
1294 struct Invoker<1, StorageType, R(X1, X2, X3)> {
1295   typedef R(RunType)(BindStateBase*,
1296       typename CallbackParamTraits<X2>::ForwardType,
1297       typename CallbackParamTraits<X3>::ForwardType);
1298
1299   typedef R(UnboundRunType)(X2, X3);
1300
1301   static R Run(BindStateBase* base,
1302       typename CallbackParamTraits<X2>::ForwardType x2,
1303       typename CallbackParamTraits<X3>::ForwardType x3) {
1304     StorageType* storage = static_cast<StorageType*>(base);
1305
1306     // Local references to make debugger stepping easier. If in a debugger,
1307     // you really want to warp ahead and step through the
1308     // InvokeHelper<>::MakeItSo() call below.
1309     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1310
1311     typename Bound1UnwrapTraits::ForwardType x1 =
1312         Bound1UnwrapTraits::Unwrap(storage->p1_);
1313     return InvokeHelper<StorageType::IsWeakCall::value, R,
1314            typename StorageType::RunnableType,
1315            void(typename Bound1UnwrapTraits::ForwardType,
1316                typename CallbackParamTraits<X2>::ForwardType x2,
1317                typename CallbackParamTraits<X3>::ForwardType x3)>
1318                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1319                    CallbackForward(x2), CallbackForward(x3));
1320   }
1321 };
1322
1323 // Arity 3 -> 1.
1324 template <typename StorageType, typename R,typename X1, typename X2,
1325     typename X3>
1326 struct Invoker<2, StorageType, R(X1, X2, X3)> {
1327   typedef R(RunType)(BindStateBase*,
1328       typename CallbackParamTraits<X3>::ForwardType);
1329
1330   typedef R(UnboundRunType)(X3);
1331
1332   static R Run(BindStateBase* base,
1333       typename CallbackParamTraits<X3>::ForwardType x3) {
1334     StorageType* storage = static_cast<StorageType*>(base);
1335
1336     // Local references to make debugger stepping easier. If in a debugger,
1337     // you really want to warp ahead and step through the
1338     // InvokeHelper<>::MakeItSo() call below.
1339     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1340     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1341
1342     typename Bound1UnwrapTraits::ForwardType x1 =
1343         Bound1UnwrapTraits::Unwrap(storage->p1_);
1344     typename Bound2UnwrapTraits::ForwardType x2 =
1345         Bound2UnwrapTraits::Unwrap(storage->p2_);
1346     return InvokeHelper<StorageType::IsWeakCall::value, R,
1347            typename StorageType::RunnableType,
1348            void(typename Bound1UnwrapTraits::ForwardType,
1349                typename Bound2UnwrapTraits::ForwardType,
1350                typename CallbackParamTraits<X3>::ForwardType x3)>
1351                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1352                    CallbackForward(x2), CallbackForward(x3));
1353   }
1354 };
1355
1356 // Arity 3 -> 0.
1357 template <typename StorageType, typename R,typename X1, typename X2,
1358     typename X3>
1359 struct Invoker<3, StorageType, R(X1, X2, X3)> {
1360   typedef R(RunType)(BindStateBase*);
1361
1362   typedef R(UnboundRunType)();
1363
1364   static R Run(BindStateBase* base) {
1365     StorageType* storage = static_cast<StorageType*>(base);
1366
1367     // Local references to make debugger stepping easier. If in a debugger,
1368     // you really want to warp ahead and step through the
1369     // InvokeHelper<>::MakeItSo() call below.
1370     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1371     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1372     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1373
1374     typename Bound1UnwrapTraits::ForwardType x1 =
1375         Bound1UnwrapTraits::Unwrap(storage->p1_);
1376     typename Bound2UnwrapTraits::ForwardType x2 =
1377         Bound2UnwrapTraits::Unwrap(storage->p2_);
1378     typename Bound3UnwrapTraits::ForwardType x3 =
1379         Bound3UnwrapTraits::Unwrap(storage->p3_);
1380     return InvokeHelper<StorageType::IsWeakCall::value, R,
1381            typename StorageType::RunnableType,
1382            void(typename Bound1UnwrapTraits::ForwardType,
1383                typename Bound2UnwrapTraits::ForwardType,
1384                typename Bound3UnwrapTraits::ForwardType)>
1385                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1386                    CallbackForward(x2), CallbackForward(x3));
1387   }
1388 };
1389
1390 // Arity 4 -> 4.
1391 template <typename StorageType, typename R,typename X1, typename X2,
1392     typename X3, typename X4>
1393 struct Invoker<0, StorageType, R(X1, X2, X3, X4)> {
1394   typedef R(RunType)(BindStateBase*,
1395       typename CallbackParamTraits<X1>::ForwardType,
1396       typename CallbackParamTraits<X2>::ForwardType,
1397       typename CallbackParamTraits<X3>::ForwardType,
1398       typename CallbackParamTraits<X4>::ForwardType);
1399
1400   typedef R(UnboundRunType)(X1, X2, X3, X4);
1401
1402   static R Run(BindStateBase* base,
1403       typename CallbackParamTraits<X1>::ForwardType x1,
1404       typename CallbackParamTraits<X2>::ForwardType x2,
1405       typename CallbackParamTraits<X3>::ForwardType x3,
1406       typename CallbackParamTraits<X4>::ForwardType x4) {
1407     StorageType* storage = static_cast<StorageType*>(base);
1408
1409     // Local references to make debugger stepping easier. If in a debugger,
1410     // you really want to warp ahead and step through the
1411     // InvokeHelper<>::MakeItSo() call below.
1412
1413     return InvokeHelper<StorageType::IsWeakCall::value, R,
1414            typename StorageType::RunnableType,
1415            void(typename CallbackParamTraits<X1>::ForwardType x1,
1416                typename CallbackParamTraits<X2>::ForwardType x2,
1417                typename CallbackParamTraits<X3>::ForwardType x3,
1418                typename CallbackParamTraits<X4>::ForwardType x4)>
1419                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1420                    CallbackForward(x2), CallbackForward(x3),
1421                    CallbackForward(x4));
1422   }
1423 };
1424
1425 // Arity 4 -> 3.
1426 template <typename StorageType, typename R,typename X1, typename X2,
1427     typename X3, typename X4>
1428 struct Invoker<1, StorageType, R(X1, X2, X3, X4)> {
1429   typedef R(RunType)(BindStateBase*,
1430       typename CallbackParamTraits<X2>::ForwardType,
1431       typename CallbackParamTraits<X3>::ForwardType,
1432       typename CallbackParamTraits<X4>::ForwardType);
1433
1434   typedef R(UnboundRunType)(X2, X3, X4);
1435
1436   static R Run(BindStateBase* base,
1437       typename CallbackParamTraits<X2>::ForwardType x2,
1438       typename CallbackParamTraits<X3>::ForwardType x3,
1439       typename CallbackParamTraits<X4>::ForwardType x4) {
1440     StorageType* storage = static_cast<StorageType*>(base);
1441
1442     // Local references to make debugger stepping easier. If in a debugger,
1443     // you really want to warp ahead and step through the
1444     // InvokeHelper<>::MakeItSo() call below.
1445     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1446
1447     typename Bound1UnwrapTraits::ForwardType x1 =
1448         Bound1UnwrapTraits::Unwrap(storage->p1_);
1449     return InvokeHelper<StorageType::IsWeakCall::value, R,
1450            typename StorageType::RunnableType,
1451            void(typename Bound1UnwrapTraits::ForwardType,
1452                typename CallbackParamTraits<X2>::ForwardType x2,
1453                typename CallbackParamTraits<X3>::ForwardType x3,
1454                typename CallbackParamTraits<X4>::ForwardType x4)>
1455                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1456                    CallbackForward(x2), CallbackForward(x3),
1457                    CallbackForward(x4));
1458   }
1459 };
1460
1461 // Arity 4 -> 2.
1462 template <typename StorageType, typename R,typename X1, typename X2,
1463     typename X3, typename X4>
1464 struct Invoker<2, StorageType, R(X1, X2, X3, X4)> {
1465   typedef R(RunType)(BindStateBase*,
1466       typename CallbackParamTraits<X3>::ForwardType,
1467       typename CallbackParamTraits<X4>::ForwardType);
1468
1469   typedef R(UnboundRunType)(X3, X4);
1470
1471   static R Run(BindStateBase* base,
1472       typename CallbackParamTraits<X3>::ForwardType x3,
1473       typename CallbackParamTraits<X4>::ForwardType x4) {
1474     StorageType* storage = static_cast<StorageType*>(base);
1475
1476     // Local references to make debugger stepping easier. If in a debugger,
1477     // you really want to warp ahead and step through the
1478     // InvokeHelper<>::MakeItSo() call below.
1479     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1480     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1481
1482     typename Bound1UnwrapTraits::ForwardType x1 =
1483         Bound1UnwrapTraits::Unwrap(storage->p1_);
1484     typename Bound2UnwrapTraits::ForwardType x2 =
1485         Bound2UnwrapTraits::Unwrap(storage->p2_);
1486     return InvokeHelper<StorageType::IsWeakCall::value, R,
1487            typename StorageType::RunnableType,
1488            void(typename Bound1UnwrapTraits::ForwardType,
1489                typename Bound2UnwrapTraits::ForwardType,
1490                typename CallbackParamTraits<X3>::ForwardType x3,
1491                typename CallbackParamTraits<X4>::ForwardType x4)>
1492                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1493                    CallbackForward(x2), CallbackForward(x3),
1494                    CallbackForward(x4));
1495   }
1496 };
1497
1498 // Arity 4 -> 1.
1499 template <typename StorageType, typename R,typename X1, typename X2,
1500     typename X3, typename X4>
1501 struct Invoker<3, StorageType, R(X1, X2, X3, X4)> {
1502   typedef R(RunType)(BindStateBase*,
1503       typename CallbackParamTraits<X4>::ForwardType);
1504
1505   typedef R(UnboundRunType)(X4);
1506
1507   static R Run(BindStateBase* base,
1508       typename CallbackParamTraits<X4>::ForwardType x4) {
1509     StorageType* storage = static_cast<StorageType*>(base);
1510
1511     // Local references to make debugger stepping easier. If in a debugger,
1512     // you really want to warp ahead and step through the
1513     // InvokeHelper<>::MakeItSo() call below.
1514     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1515     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1516     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1517
1518     typename Bound1UnwrapTraits::ForwardType x1 =
1519         Bound1UnwrapTraits::Unwrap(storage->p1_);
1520     typename Bound2UnwrapTraits::ForwardType x2 =
1521         Bound2UnwrapTraits::Unwrap(storage->p2_);
1522     typename Bound3UnwrapTraits::ForwardType x3 =
1523         Bound3UnwrapTraits::Unwrap(storage->p3_);
1524     return InvokeHelper<StorageType::IsWeakCall::value, R,
1525            typename StorageType::RunnableType,
1526            void(typename Bound1UnwrapTraits::ForwardType,
1527                typename Bound2UnwrapTraits::ForwardType,
1528                typename Bound3UnwrapTraits::ForwardType,
1529                typename CallbackParamTraits<X4>::ForwardType x4)>
1530                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1531                    CallbackForward(x2), CallbackForward(x3),
1532                    CallbackForward(x4));
1533   }
1534 };
1535
1536 // Arity 4 -> 0.
1537 template <typename StorageType, typename R,typename X1, typename X2,
1538     typename X3, typename X4>
1539 struct Invoker<4, StorageType, R(X1, X2, X3, X4)> {
1540   typedef R(RunType)(BindStateBase*);
1541
1542   typedef R(UnboundRunType)();
1543
1544   static R Run(BindStateBase* base) {
1545     StorageType* storage = static_cast<StorageType*>(base);
1546
1547     // Local references to make debugger stepping easier. If in a debugger,
1548     // you really want to warp ahead and step through the
1549     // InvokeHelper<>::MakeItSo() call below.
1550     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1551     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1552     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1553     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1554
1555     typename Bound1UnwrapTraits::ForwardType x1 =
1556         Bound1UnwrapTraits::Unwrap(storage->p1_);
1557     typename Bound2UnwrapTraits::ForwardType x2 =
1558         Bound2UnwrapTraits::Unwrap(storage->p2_);
1559     typename Bound3UnwrapTraits::ForwardType x3 =
1560         Bound3UnwrapTraits::Unwrap(storage->p3_);
1561     typename Bound4UnwrapTraits::ForwardType x4 =
1562         Bound4UnwrapTraits::Unwrap(storage->p4_);
1563     return InvokeHelper<StorageType::IsWeakCall::value, R,
1564            typename StorageType::RunnableType,
1565            void(typename Bound1UnwrapTraits::ForwardType,
1566                typename Bound2UnwrapTraits::ForwardType,
1567                typename Bound3UnwrapTraits::ForwardType,
1568                typename Bound4UnwrapTraits::ForwardType)>
1569                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1570                    CallbackForward(x2), CallbackForward(x3),
1571                    CallbackForward(x4));
1572   }
1573 };
1574
1575 // Arity 5 -> 5.
1576 template <typename StorageType, typename R,typename X1, typename X2,
1577     typename X3, typename X4, typename X5>
1578 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> {
1579   typedef R(RunType)(BindStateBase*,
1580       typename CallbackParamTraits<X1>::ForwardType,
1581       typename CallbackParamTraits<X2>::ForwardType,
1582       typename CallbackParamTraits<X3>::ForwardType,
1583       typename CallbackParamTraits<X4>::ForwardType,
1584       typename CallbackParamTraits<X5>::ForwardType);
1585
1586   typedef R(UnboundRunType)(X1, X2, X3, X4, X5);
1587
1588   static R Run(BindStateBase* base,
1589       typename CallbackParamTraits<X1>::ForwardType x1,
1590       typename CallbackParamTraits<X2>::ForwardType x2,
1591       typename CallbackParamTraits<X3>::ForwardType x3,
1592       typename CallbackParamTraits<X4>::ForwardType x4,
1593       typename CallbackParamTraits<X5>::ForwardType x5) {
1594     StorageType* storage = static_cast<StorageType*>(base);
1595
1596     // Local references to make debugger stepping easier. If in a debugger,
1597     // you really want to warp ahead and step through the
1598     // InvokeHelper<>::MakeItSo() call below.
1599
1600     return InvokeHelper<StorageType::IsWeakCall::value, R,
1601            typename StorageType::RunnableType,
1602            void(typename CallbackParamTraits<X1>::ForwardType x1,
1603                typename CallbackParamTraits<X2>::ForwardType x2,
1604                typename CallbackParamTraits<X3>::ForwardType x3,
1605                typename CallbackParamTraits<X4>::ForwardType x4,
1606                typename CallbackParamTraits<X5>::ForwardType x5)>
1607                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1608                    CallbackForward(x2), CallbackForward(x3),
1609                    CallbackForward(x4), CallbackForward(x5));
1610   }
1611 };
1612
1613 // Arity 5 -> 4.
1614 template <typename StorageType, typename R,typename X1, typename X2,
1615     typename X3, typename X4, typename X5>
1616 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> {
1617   typedef R(RunType)(BindStateBase*,
1618       typename CallbackParamTraits<X2>::ForwardType,
1619       typename CallbackParamTraits<X3>::ForwardType,
1620       typename CallbackParamTraits<X4>::ForwardType,
1621       typename CallbackParamTraits<X5>::ForwardType);
1622
1623   typedef R(UnboundRunType)(X2, X3, X4, X5);
1624
1625   static R Run(BindStateBase* base,
1626       typename CallbackParamTraits<X2>::ForwardType x2,
1627       typename CallbackParamTraits<X3>::ForwardType x3,
1628       typename CallbackParamTraits<X4>::ForwardType x4,
1629       typename CallbackParamTraits<X5>::ForwardType x5) {
1630     StorageType* storage = static_cast<StorageType*>(base);
1631
1632     // Local references to make debugger stepping easier. If in a debugger,
1633     // you really want to warp ahead and step through the
1634     // InvokeHelper<>::MakeItSo() call below.
1635     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1636
1637     typename Bound1UnwrapTraits::ForwardType x1 =
1638         Bound1UnwrapTraits::Unwrap(storage->p1_);
1639     return InvokeHelper<StorageType::IsWeakCall::value, R,
1640            typename StorageType::RunnableType,
1641            void(typename Bound1UnwrapTraits::ForwardType,
1642                typename CallbackParamTraits<X2>::ForwardType x2,
1643                typename CallbackParamTraits<X3>::ForwardType x3,
1644                typename CallbackParamTraits<X4>::ForwardType x4,
1645                typename CallbackParamTraits<X5>::ForwardType x5)>
1646                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1647                    CallbackForward(x2), CallbackForward(x3),
1648                    CallbackForward(x4), CallbackForward(x5));
1649   }
1650 };
1651
1652 // Arity 5 -> 3.
1653 template <typename StorageType, typename R,typename X1, typename X2,
1654     typename X3, typename X4, typename X5>
1655 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> {
1656   typedef R(RunType)(BindStateBase*,
1657       typename CallbackParamTraits<X3>::ForwardType,
1658       typename CallbackParamTraits<X4>::ForwardType,
1659       typename CallbackParamTraits<X5>::ForwardType);
1660
1661   typedef R(UnboundRunType)(X3, X4, X5);
1662
1663   static R Run(BindStateBase* base,
1664       typename CallbackParamTraits<X3>::ForwardType x3,
1665       typename CallbackParamTraits<X4>::ForwardType x4,
1666       typename CallbackParamTraits<X5>::ForwardType x5) {
1667     StorageType* storage = static_cast<StorageType*>(base);
1668
1669     // Local references to make debugger stepping easier. If in a debugger,
1670     // you really want to warp ahead and step through the
1671     // InvokeHelper<>::MakeItSo() call below.
1672     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1673     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1674
1675     typename Bound1UnwrapTraits::ForwardType x1 =
1676         Bound1UnwrapTraits::Unwrap(storage->p1_);
1677     typename Bound2UnwrapTraits::ForwardType x2 =
1678         Bound2UnwrapTraits::Unwrap(storage->p2_);
1679     return InvokeHelper<StorageType::IsWeakCall::value, R,
1680            typename StorageType::RunnableType,
1681            void(typename Bound1UnwrapTraits::ForwardType,
1682                typename Bound2UnwrapTraits::ForwardType,
1683                typename CallbackParamTraits<X3>::ForwardType x3,
1684                typename CallbackParamTraits<X4>::ForwardType x4,
1685                typename CallbackParamTraits<X5>::ForwardType x5)>
1686                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1687                    CallbackForward(x2), CallbackForward(x3),
1688                    CallbackForward(x4), CallbackForward(x5));
1689   }
1690 };
1691
1692 // Arity 5 -> 2.
1693 template <typename StorageType, typename R,typename X1, typename X2,
1694     typename X3, typename X4, typename X5>
1695 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> {
1696   typedef R(RunType)(BindStateBase*,
1697       typename CallbackParamTraits<X4>::ForwardType,
1698       typename CallbackParamTraits<X5>::ForwardType);
1699
1700   typedef R(UnboundRunType)(X4, X5);
1701
1702   static R Run(BindStateBase* base,
1703       typename CallbackParamTraits<X4>::ForwardType x4,
1704       typename CallbackParamTraits<X5>::ForwardType x5) {
1705     StorageType* storage = static_cast<StorageType*>(base);
1706
1707     // Local references to make debugger stepping easier. If in a debugger,
1708     // you really want to warp ahead and step through the
1709     // InvokeHelper<>::MakeItSo() call below.
1710     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1711     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1712     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1713
1714     typename Bound1UnwrapTraits::ForwardType x1 =
1715         Bound1UnwrapTraits::Unwrap(storage->p1_);
1716     typename Bound2UnwrapTraits::ForwardType x2 =
1717         Bound2UnwrapTraits::Unwrap(storage->p2_);
1718     typename Bound3UnwrapTraits::ForwardType x3 =
1719         Bound3UnwrapTraits::Unwrap(storage->p3_);
1720     return InvokeHelper<StorageType::IsWeakCall::value, R,
1721            typename StorageType::RunnableType,
1722            void(typename Bound1UnwrapTraits::ForwardType,
1723                typename Bound2UnwrapTraits::ForwardType,
1724                typename Bound3UnwrapTraits::ForwardType,
1725                typename CallbackParamTraits<X4>::ForwardType x4,
1726                typename CallbackParamTraits<X5>::ForwardType x5)>
1727                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1728                    CallbackForward(x2), CallbackForward(x3),
1729                    CallbackForward(x4), CallbackForward(x5));
1730   }
1731 };
1732
1733 // Arity 5 -> 1.
1734 template <typename StorageType, typename R,typename X1, typename X2,
1735     typename X3, typename X4, typename X5>
1736 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> {
1737   typedef R(RunType)(BindStateBase*,
1738       typename CallbackParamTraits<X5>::ForwardType);
1739
1740   typedef R(UnboundRunType)(X5);
1741
1742   static R Run(BindStateBase* base,
1743       typename CallbackParamTraits<X5>::ForwardType x5) {
1744     StorageType* storage = static_cast<StorageType*>(base);
1745
1746     // Local references to make debugger stepping easier. If in a debugger,
1747     // you really want to warp ahead and step through the
1748     // InvokeHelper<>::MakeItSo() call below.
1749     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1750     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1751     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1752     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1753
1754     typename Bound1UnwrapTraits::ForwardType x1 =
1755         Bound1UnwrapTraits::Unwrap(storage->p1_);
1756     typename Bound2UnwrapTraits::ForwardType x2 =
1757         Bound2UnwrapTraits::Unwrap(storage->p2_);
1758     typename Bound3UnwrapTraits::ForwardType x3 =
1759         Bound3UnwrapTraits::Unwrap(storage->p3_);
1760     typename Bound4UnwrapTraits::ForwardType x4 =
1761         Bound4UnwrapTraits::Unwrap(storage->p4_);
1762     return InvokeHelper<StorageType::IsWeakCall::value, R,
1763            typename StorageType::RunnableType,
1764            void(typename Bound1UnwrapTraits::ForwardType,
1765                typename Bound2UnwrapTraits::ForwardType,
1766                typename Bound3UnwrapTraits::ForwardType,
1767                typename Bound4UnwrapTraits::ForwardType,
1768                typename CallbackParamTraits<X5>::ForwardType x5)>
1769                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1770                    CallbackForward(x2), CallbackForward(x3),
1771                    CallbackForward(x4), CallbackForward(x5));
1772   }
1773 };
1774
1775 // Arity 5 -> 0.
1776 template <typename StorageType, typename R,typename X1, typename X2,
1777     typename X3, typename X4, typename X5>
1778 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> {
1779   typedef R(RunType)(BindStateBase*);
1780
1781   typedef R(UnboundRunType)();
1782
1783   static R Run(BindStateBase* base) {
1784     StorageType* storage = static_cast<StorageType*>(base);
1785
1786     // Local references to make debugger stepping easier. If in a debugger,
1787     // you really want to warp ahead and step through the
1788     // InvokeHelper<>::MakeItSo() call below.
1789     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1790     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1791     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1792     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
1793     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
1794
1795     typename Bound1UnwrapTraits::ForwardType x1 =
1796         Bound1UnwrapTraits::Unwrap(storage->p1_);
1797     typename Bound2UnwrapTraits::ForwardType x2 =
1798         Bound2UnwrapTraits::Unwrap(storage->p2_);
1799     typename Bound3UnwrapTraits::ForwardType x3 =
1800         Bound3UnwrapTraits::Unwrap(storage->p3_);
1801     typename Bound4UnwrapTraits::ForwardType x4 =
1802         Bound4UnwrapTraits::Unwrap(storage->p4_);
1803     typename Bound5UnwrapTraits::ForwardType x5 =
1804         Bound5UnwrapTraits::Unwrap(storage->p5_);
1805     return InvokeHelper<StorageType::IsWeakCall::value, R,
1806            typename StorageType::RunnableType,
1807            void(typename Bound1UnwrapTraits::ForwardType,
1808                typename Bound2UnwrapTraits::ForwardType,
1809                typename Bound3UnwrapTraits::ForwardType,
1810                typename Bound4UnwrapTraits::ForwardType,
1811                typename Bound5UnwrapTraits::ForwardType)>
1812                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1813                    CallbackForward(x2), CallbackForward(x3),
1814                    CallbackForward(x4), CallbackForward(x5));
1815   }
1816 };
1817
1818 // Arity 6 -> 6.
1819 template <typename StorageType, typename R,typename X1, typename X2,
1820     typename X3, typename X4, typename X5, typename X6>
1821 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1822   typedef R(RunType)(BindStateBase*,
1823       typename CallbackParamTraits<X1>::ForwardType,
1824       typename CallbackParamTraits<X2>::ForwardType,
1825       typename CallbackParamTraits<X3>::ForwardType,
1826       typename CallbackParamTraits<X4>::ForwardType,
1827       typename CallbackParamTraits<X5>::ForwardType,
1828       typename CallbackParamTraits<X6>::ForwardType);
1829
1830   typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6);
1831
1832   static R Run(BindStateBase* base,
1833       typename CallbackParamTraits<X1>::ForwardType x1,
1834       typename CallbackParamTraits<X2>::ForwardType x2,
1835       typename CallbackParamTraits<X3>::ForwardType x3,
1836       typename CallbackParamTraits<X4>::ForwardType x4,
1837       typename CallbackParamTraits<X5>::ForwardType x5,
1838       typename CallbackParamTraits<X6>::ForwardType x6) {
1839     StorageType* storage = static_cast<StorageType*>(base);
1840
1841     // Local references to make debugger stepping easier. If in a debugger,
1842     // you really want to warp ahead and step through the
1843     // InvokeHelper<>::MakeItSo() call below.
1844
1845     return InvokeHelper<StorageType::IsWeakCall::value, R,
1846            typename StorageType::RunnableType,
1847            void(typename CallbackParamTraits<X1>::ForwardType x1,
1848                typename CallbackParamTraits<X2>::ForwardType x2,
1849                typename CallbackParamTraits<X3>::ForwardType x3,
1850                typename CallbackParamTraits<X4>::ForwardType x4,
1851                typename CallbackParamTraits<X5>::ForwardType x5,
1852                typename CallbackParamTraits<X6>::ForwardType x6)>
1853                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1854                    CallbackForward(x2), CallbackForward(x3),
1855                    CallbackForward(x4), CallbackForward(x5),
1856                    CallbackForward(x6));
1857   }
1858 };
1859
1860 // Arity 6 -> 5.
1861 template <typename StorageType, typename R,typename X1, typename X2,
1862     typename X3, typename X4, typename X5, typename X6>
1863 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1864   typedef R(RunType)(BindStateBase*,
1865       typename CallbackParamTraits<X2>::ForwardType,
1866       typename CallbackParamTraits<X3>::ForwardType,
1867       typename CallbackParamTraits<X4>::ForwardType,
1868       typename CallbackParamTraits<X5>::ForwardType,
1869       typename CallbackParamTraits<X6>::ForwardType);
1870
1871   typedef R(UnboundRunType)(X2, X3, X4, X5, X6);
1872
1873   static R Run(BindStateBase* base,
1874       typename CallbackParamTraits<X2>::ForwardType x2,
1875       typename CallbackParamTraits<X3>::ForwardType x3,
1876       typename CallbackParamTraits<X4>::ForwardType x4,
1877       typename CallbackParamTraits<X5>::ForwardType x5,
1878       typename CallbackParamTraits<X6>::ForwardType x6) {
1879     StorageType* storage = static_cast<StorageType*>(base);
1880
1881     // Local references to make debugger stepping easier. If in a debugger,
1882     // you really want to warp ahead and step through the
1883     // InvokeHelper<>::MakeItSo() call below.
1884     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1885
1886     typename Bound1UnwrapTraits::ForwardType x1 =
1887         Bound1UnwrapTraits::Unwrap(storage->p1_);
1888     return InvokeHelper<StorageType::IsWeakCall::value, R,
1889            typename StorageType::RunnableType,
1890            void(typename Bound1UnwrapTraits::ForwardType,
1891                typename CallbackParamTraits<X2>::ForwardType x2,
1892                typename CallbackParamTraits<X3>::ForwardType x3,
1893                typename CallbackParamTraits<X4>::ForwardType x4,
1894                typename CallbackParamTraits<X5>::ForwardType x5,
1895                typename CallbackParamTraits<X6>::ForwardType x6)>
1896                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1897                    CallbackForward(x2), CallbackForward(x3),
1898                    CallbackForward(x4), CallbackForward(x5),
1899                    CallbackForward(x6));
1900   }
1901 };
1902
1903 // Arity 6 -> 4.
1904 template <typename StorageType, typename R,typename X1, typename X2,
1905     typename X3, typename X4, typename X5, typename X6>
1906 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1907   typedef R(RunType)(BindStateBase*,
1908       typename CallbackParamTraits<X3>::ForwardType,
1909       typename CallbackParamTraits<X4>::ForwardType,
1910       typename CallbackParamTraits<X5>::ForwardType,
1911       typename CallbackParamTraits<X6>::ForwardType);
1912
1913   typedef R(UnboundRunType)(X3, X4, X5, X6);
1914
1915   static R Run(BindStateBase* base,
1916       typename CallbackParamTraits<X3>::ForwardType x3,
1917       typename CallbackParamTraits<X4>::ForwardType x4,
1918       typename CallbackParamTraits<X5>::ForwardType x5,
1919       typename CallbackParamTraits<X6>::ForwardType x6) {
1920     StorageType* storage = static_cast<StorageType*>(base);
1921
1922     // Local references to make debugger stepping easier. If in a debugger,
1923     // you really want to warp ahead and step through the
1924     // InvokeHelper<>::MakeItSo() call below.
1925     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1926     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1927
1928     typename Bound1UnwrapTraits::ForwardType x1 =
1929         Bound1UnwrapTraits::Unwrap(storage->p1_);
1930     typename Bound2UnwrapTraits::ForwardType x2 =
1931         Bound2UnwrapTraits::Unwrap(storage->p2_);
1932     return InvokeHelper<StorageType::IsWeakCall::value, R,
1933            typename StorageType::RunnableType,
1934            void(typename Bound1UnwrapTraits::ForwardType,
1935                typename Bound2UnwrapTraits::ForwardType,
1936                typename CallbackParamTraits<X3>::ForwardType x3,
1937                typename CallbackParamTraits<X4>::ForwardType x4,
1938                typename CallbackParamTraits<X5>::ForwardType x5,
1939                typename CallbackParamTraits<X6>::ForwardType x6)>
1940                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1941                    CallbackForward(x2), CallbackForward(x3),
1942                    CallbackForward(x4), CallbackForward(x5),
1943                    CallbackForward(x6));
1944   }
1945 };
1946
1947 // Arity 6 -> 3.
1948 template <typename StorageType, typename R,typename X1, typename X2,
1949     typename X3, typename X4, typename X5, typename X6>
1950 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1951   typedef R(RunType)(BindStateBase*,
1952       typename CallbackParamTraits<X4>::ForwardType,
1953       typename CallbackParamTraits<X5>::ForwardType,
1954       typename CallbackParamTraits<X6>::ForwardType);
1955
1956   typedef R(UnboundRunType)(X4, X5, X6);
1957
1958   static R Run(BindStateBase* base,
1959       typename CallbackParamTraits<X4>::ForwardType x4,
1960       typename CallbackParamTraits<X5>::ForwardType x5,
1961       typename CallbackParamTraits<X6>::ForwardType x6) {
1962     StorageType* storage = static_cast<StorageType*>(base);
1963
1964     // Local references to make debugger stepping easier. If in a debugger,
1965     // you really want to warp ahead and step through the
1966     // InvokeHelper<>::MakeItSo() call below.
1967     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
1968     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
1969     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
1970
1971     typename Bound1UnwrapTraits::ForwardType x1 =
1972         Bound1UnwrapTraits::Unwrap(storage->p1_);
1973     typename Bound2UnwrapTraits::ForwardType x2 =
1974         Bound2UnwrapTraits::Unwrap(storage->p2_);
1975     typename Bound3UnwrapTraits::ForwardType x3 =
1976         Bound3UnwrapTraits::Unwrap(storage->p3_);
1977     return InvokeHelper<StorageType::IsWeakCall::value, R,
1978            typename StorageType::RunnableType,
1979            void(typename Bound1UnwrapTraits::ForwardType,
1980                typename Bound2UnwrapTraits::ForwardType,
1981                typename Bound3UnwrapTraits::ForwardType,
1982                typename CallbackParamTraits<X4>::ForwardType x4,
1983                typename CallbackParamTraits<X5>::ForwardType x5,
1984                typename CallbackParamTraits<X6>::ForwardType x6)>
1985                ::MakeItSo(storage->runnable_, CallbackForward(x1),
1986                    CallbackForward(x2), CallbackForward(x3),
1987                    CallbackForward(x4), CallbackForward(x5),
1988                    CallbackForward(x6));
1989   }
1990 };
1991
1992 // Arity 6 -> 2.
1993 template <typename StorageType, typename R,typename X1, typename X2,
1994     typename X3, typename X4, typename X5, typename X6>
1995 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> {
1996   typedef R(RunType)(BindStateBase*,
1997       typename CallbackParamTraits<X5>::ForwardType,
1998       typename CallbackParamTraits<X6>::ForwardType);
1999
2000   typedef R(UnboundRunType)(X5, X6);
2001
2002   static R Run(BindStateBase* base,
2003       typename CallbackParamTraits<X5>::ForwardType x5,
2004       typename CallbackParamTraits<X6>::ForwardType x6) {
2005     StorageType* storage = static_cast<StorageType*>(base);
2006
2007     // Local references to make debugger stepping easier. If in a debugger,
2008     // you really want to warp ahead and step through the
2009     // InvokeHelper<>::MakeItSo() call below.
2010     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2011     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2012     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2013     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2014
2015     typename Bound1UnwrapTraits::ForwardType x1 =
2016         Bound1UnwrapTraits::Unwrap(storage->p1_);
2017     typename Bound2UnwrapTraits::ForwardType x2 =
2018         Bound2UnwrapTraits::Unwrap(storage->p2_);
2019     typename Bound3UnwrapTraits::ForwardType x3 =
2020         Bound3UnwrapTraits::Unwrap(storage->p3_);
2021     typename Bound4UnwrapTraits::ForwardType x4 =
2022         Bound4UnwrapTraits::Unwrap(storage->p4_);
2023     return InvokeHelper<StorageType::IsWeakCall::value, R,
2024            typename StorageType::RunnableType,
2025            void(typename Bound1UnwrapTraits::ForwardType,
2026                typename Bound2UnwrapTraits::ForwardType,
2027                typename Bound3UnwrapTraits::ForwardType,
2028                typename Bound4UnwrapTraits::ForwardType,
2029                typename CallbackParamTraits<X5>::ForwardType x5,
2030                typename CallbackParamTraits<X6>::ForwardType x6)>
2031                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2032                    CallbackForward(x2), CallbackForward(x3),
2033                    CallbackForward(x4), CallbackForward(x5),
2034                    CallbackForward(x6));
2035   }
2036 };
2037
2038 // Arity 6 -> 1.
2039 template <typename StorageType, typename R,typename X1, typename X2,
2040     typename X3, typename X4, typename X5, typename X6>
2041 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> {
2042   typedef R(RunType)(BindStateBase*,
2043       typename CallbackParamTraits<X6>::ForwardType);
2044
2045   typedef R(UnboundRunType)(X6);
2046
2047   static R Run(BindStateBase* base,
2048       typename CallbackParamTraits<X6>::ForwardType x6) {
2049     StorageType* storage = static_cast<StorageType*>(base);
2050
2051     // Local references to make debugger stepping easier. If in a debugger,
2052     // you really want to warp ahead and step through the
2053     // InvokeHelper<>::MakeItSo() call below.
2054     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2055     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2056     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2057     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2058     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2059
2060     typename Bound1UnwrapTraits::ForwardType x1 =
2061         Bound1UnwrapTraits::Unwrap(storage->p1_);
2062     typename Bound2UnwrapTraits::ForwardType x2 =
2063         Bound2UnwrapTraits::Unwrap(storage->p2_);
2064     typename Bound3UnwrapTraits::ForwardType x3 =
2065         Bound3UnwrapTraits::Unwrap(storage->p3_);
2066     typename Bound4UnwrapTraits::ForwardType x4 =
2067         Bound4UnwrapTraits::Unwrap(storage->p4_);
2068     typename Bound5UnwrapTraits::ForwardType x5 =
2069         Bound5UnwrapTraits::Unwrap(storage->p5_);
2070     return InvokeHelper<StorageType::IsWeakCall::value, R,
2071            typename StorageType::RunnableType,
2072            void(typename Bound1UnwrapTraits::ForwardType,
2073                typename Bound2UnwrapTraits::ForwardType,
2074                typename Bound3UnwrapTraits::ForwardType,
2075                typename Bound4UnwrapTraits::ForwardType,
2076                typename Bound5UnwrapTraits::ForwardType,
2077                typename CallbackParamTraits<X6>::ForwardType x6)>
2078                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2079                    CallbackForward(x2), CallbackForward(x3),
2080                    CallbackForward(x4), CallbackForward(x5),
2081                    CallbackForward(x6));
2082   }
2083 };
2084
2085 // Arity 6 -> 0.
2086 template <typename StorageType, typename R,typename X1, typename X2,
2087     typename X3, typename X4, typename X5, typename X6>
2088 struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> {
2089   typedef R(RunType)(BindStateBase*);
2090
2091   typedef R(UnboundRunType)();
2092
2093   static R Run(BindStateBase* base) {
2094     StorageType* storage = static_cast<StorageType*>(base);
2095
2096     // Local references to make debugger stepping easier. If in a debugger,
2097     // you really want to warp ahead and step through the
2098     // InvokeHelper<>::MakeItSo() call below.
2099     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2100     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2101     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2102     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2103     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2104     typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2105
2106     typename Bound1UnwrapTraits::ForwardType x1 =
2107         Bound1UnwrapTraits::Unwrap(storage->p1_);
2108     typename Bound2UnwrapTraits::ForwardType x2 =
2109         Bound2UnwrapTraits::Unwrap(storage->p2_);
2110     typename Bound3UnwrapTraits::ForwardType x3 =
2111         Bound3UnwrapTraits::Unwrap(storage->p3_);
2112     typename Bound4UnwrapTraits::ForwardType x4 =
2113         Bound4UnwrapTraits::Unwrap(storage->p4_);
2114     typename Bound5UnwrapTraits::ForwardType x5 =
2115         Bound5UnwrapTraits::Unwrap(storage->p5_);
2116     typename Bound6UnwrapTraits::ForwardType x6 =
2117         Bound6UnwrapTraits::Unwrap(storage->p6_);
2118     return InvokeHelper<StorageType::IsWeakCall::value, R,
2119            typename StorageType::RunnableType,
2120            void(typename Bound1UnwrapTraits::ForwardType,
2121                typename Bound2UnwrapTraits::ForwardType,
2122                typename Bound3UnwrapTraits::ForwardType,
2123                typename Bound4UnwrapTraits::ForwardType,
2124                typename Bound5UnwrapTraits::ForwardType,
2125                typename Bound6UnwrapTraits::ForwardType)>
2126                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2127                    CallbackForward(x2), CallbackForward(x3),
2128                    CallbackForward(x4), CallbackForward(x5),
2129                    CallbackForward(x6));
2130   }
2131 };
2132
2133 // Arity 7 -> 7.
2134 template <typename StorageType, typename R,typename X1, typename X2,
2135     typename X3, typename X4, typename X5, typename X6, typename X7>
2136 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2137   typedef R(RunType)(BindStateBase*,
2138       typename CallbackParamTraits<X1>::ForwardType,
2139       typename CallbackParamTraits<X2>::ForwardType,
2140       typename CallbackParamTraits<X3>::ForwardType,
2141       typename CallbackParamTraits<X4>::ForwardType,
2142       typename CallbackParamTraits<X5>::ForwardType,
2143       typename CallbackParamTraits<X6>::ForwardType,
2144       typename CallbackParamTraits<X7>::ForwardType);
2145
2146   typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7);
2147
2148   static R Run(BindStateBase* base,
2149       typename CallbackParamTraits<X1>::ForwardType x1,
2150       typename CallbackParamTraits<X2>::ForwardType x2,
2151       typename CallbackParamTraits<X3>::ForwardType x3,
2152       typename CallbackParamTraits<X4>::ForwardType x4,
2153       typename CallbackParamTraits<X5>::ForwardType x5,
2154       typename CallbackParamTraits<X6>::ForwardType x6,
2155       typename CallbackParamTraits<X7>::ForwardType x7) {
2156     StorageType* storage = static_cast<StorageType*>(base);
2157
2158     // Local references to make debugger stepping easier. If in a debugger,
2159     // you really want to warp ahead and step through the
2160     // InvokeHelper<>::MakeItSo() call below.
2161
2162     return InvokeHelper<StorageType::IsWeakCall::value, R,
2163            typename StorageType::RunnableType,
2164            void(typename CallbackParamTraits<X1>::ForwardType x1,
2165                typename CallbackParamTraits<X2>::ForwardType x2,
2166                typename CallbackParamTraits<X3>::ForwardType x3,
2167                typename CallbackParamTraits<X4>::ForwardType x4,
2168                typename CallbackParamTraits<X5>::ForwardType x5,
2169                typename CallbackParamTraits<X6>::ForwardType x6,
2170                typename CallbackParamTraits<X7>::ForwardType x7)>
2171                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2172                    CallbackForward(x2), CallbackForward(x3),
2173                    CallbackForward(x4), CallbackForward(x5),
2174                    CallbackForward(x6), CallbackForward(x7));
2175   }
2176 };
2177
2178 // Arity 7 -> 6.
2179 template <typename StorageType, typename R,typename X1, typename X2,
2180     typename X3, typename X4, typename X5, typename X6, typename X7>
2181 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2182   typedef R(RunType)(BindStateBase*,
2183       typename CallbackParamTraits<X2>::ForwardType,
2184       typename CallbackParamTraits<X3>::ForwardType,
2185       typename CallbackParamTraits<X4>::ForwardType,
2186       typename CallbackParamTraits<X5>::ForwardType,
2187       typename CallbackParamTraits<X6>::ForwardType,
2188       typename CallbackParamTraits<X7>::ForwardType);
2189
2190   typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7);
2191
2192   static R Run(BindStateBase* base,
2193       typename CallbackParamTraits<X2>::ForwardType x2,
2194       typename CallbackParamTraits<X3>::ForwardType x3,
2195       typename CallbackParamTraits<X4>::ForwardType x4,
2196       typename CallbackParamTraits<X5>::ForwardType x5,
2197       typename CallbackParamTraits<X6>::ForwardType x6,
2198       typename CallbackParamTraits<X7>::ForwardType x7) {
2199     StorageType* storage = static_cast<StorageType*>(base);
2200
2201     // Local references to make debugger stepping easier. If in a debugger,
2202     // you really want to warp ahead and step through the
2203     // InvokeHelper<>::MakeItSo() call below.
2204     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2205
2206     typename Bound1UnwrapTraits::ForwardType x1 =
2207         Bound1UnwrapTraits::Unwrap(storage->p1_);
2208     return InvokeHelper<StorageType::IsWeakCall::value, R,
2209            typename StorageType::RunnableType,
2210            void(typename Bound1UnwrapTraits::ForwardType,
2211                typename CallbackParamTraits<X2>::ForwardType x2,
2212                typename CallbackParamTraits<X3>::ForwardType x3,
2213                typename CallbackParamTraits<X4>::ForwardType x4,
2214                typename CallbackParamTraits<X5>::ForwardType x5,
2215                typename CallbackParamTraits<X6>::ForwardType x6,
2216                typename CallbackParamTraits<X7>::ForwardType x7)>
2217                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2218                    CallbackForward(x2), CallbackForward(x3),
2219                    CallbackForward(x4), CallbackForward(x5),
2220                    CallbackForward(x6), CallbackForward(x7));
2221   }
2222 };
2223
2224 // Arity 7 -> 5.
2225 template <typename StorageType, typename R,typename X1, typename X2,
2226     typename X3, typename X4, typename X5, typename X6, typename X7>
2227 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2228   typedef R(RunType)(BindStateBase*,
2229       typename CallbackParamTraits<X3>::ForwardType,
2230       typename CallbackParamTraits<X4>::ForwardType,
2231       typename CallbackParamTraits<X5>::ForwardType,
2232       typename CallbackParamTraits<X6>::ForwardType,
2233       typename CallbackParamTraits<X7>::ForwardType);
2234
2235   typedef R(UnboundRunType)(X3, X4, X5, X6, X7);
2236
2237   static R Run(BindStateBase* base,
2238       typename CallbackParamTraits<X3>::ForwardType x3,
2239       typename CallbackParamTraits<X4>::ForwardType x4,
2240       typename CallbackParamTraits<X5>::ForwardType x5,
2241       typename CallbackParamTraits<X6>::ForwardType x6,
2242       typename CallbackParamTraits<X7>::ForwardType x7) {
2243     StorageType* storage = static_cast<StorageType*>(base);
2244
2245     // Local references to make debugger stepping easier. If in a debugger,
2246     // you really want to warp ahead and step through the
2247     // InvokeHelper<>::MakeItSo() call below.
2248     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2249     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2250
2251     typename Bound1UnwrapTraits::ForwardType x1 =
2252         Bound1UnwrapTraits::Unwrap(storage->p1_);
2253     typename Bound2UnwrapTraits::ForwardType x2 =
2254         Bound2UnwrapTraits::Unwrap(storage->p2_);
2255     return InvokeHelper<StorageType::IsWeakCall::value, R,
2256            typename StorageType::RunnableType,
2257            void(typename Bound1UnwrapTraits::ForwardType,
2258                typename Bound2UnwrapTraits::ForwardType,
2259                typename CallbackParamTraits<X3>::ForwardType x3,
2260                typename CallbackParamTraits<X4>::ForwardType x4,
2261                typename CallbackParamTraits<X5>::ForwardType x5,
2262                typename CallbackParamTraits<X6>::ForwardType x6,
2263                typename CallbackParamTraits<X7>::ForwardType x7)>
2264                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2265                    CallbackForward(x2), CallbackForward(x3),
2266                    CallbackForward(x4), CallbackForward(x5),
2267                    CallbackForward(x6), CallbackForward(x7));
2268   }
2269 };
2270
2271 // Arity 7 -> 4.
2272 template <typename StorageType, typename R,typename X1, typename X2,
2273     typename X3, typename X4, typename X5, typename X6, typename X7>
2274 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2275   typedef R(RunType)(BindStateBase*,
2276       typename CallbackParamTraits<X4>::ForwardType,
2277       typename CallbackParamTraits<X5>::ForwardType,
2278       typename CallbackParamTraits<X6>::ForwardType,
2279       typename CallbackParamTraits<X7>::ForwardType);
2280
2281   typedef R(UnboundRunType)(X4, X5, X6, X7);
2282
2283   static R Run(BindStateBase* base,
2284       typename CallbackParamTraits<X4>::ForwardType x4,
2285       typename CallbackParamTraits<X5>::ForwardType x5,
2286       typename CallbackParamTraits<X6>::ForwardType x6,
2287       typename CallbackParamTraits<X7>::ForwardType x7) {
2288     StorageType* storage = static_cast<StorageType*>(base);
2289
2290     // Local references to make debugger stepping easier. If in a debugger,
2291     // you really want to warp ahead and step through the
2292     // InvokeHelper<>::MakeItSo() call below.
2293     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2294     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2295     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2296
2297     typename Bound1UnwrapTraits::ForwardType x1 =
2298         Bound1UnwrapTraits::Unwrap(storage->p1_);
2299     typename Bound2UnwrapTraits::ForwardType x2 =
2300         Bound2UnwrapTraits::Unwrap(storage->p2_);
2301     typename Bound3UnwrapTraits::ForwardType x3 =
2302         Bound3UnwrapTraits::Unwrap(storage->p3_);
2303     return InvokeHelper<StorageType::IsWeakCall::value, R,
2304            typename StorageType::RunnableType,
2305            void(typename Bound1UnwrapTraits::ForwardType,
2306                typename Bound2UnwrapTraits::ForwardType,
2307                typename Bound3UnwrapTraits::ForwardType,
2308                typename CallbackParamTraits<X4>::ForwardType x4,
2309                typename CallbackParamTraits<X5>::ForwardType x5,
2310                typename CallbackParamTraits<X6>::ForwardType x6,
2311                typename CallbackParamTraits<X7>::ForwardType x7)>
2312                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2313                    CallbackForward(x2), CallbackForward(x3),
2314                    CallbackForward(x4), CallbackForward(x5),
2315                    CallbackForward(x6), CallbackForward(x7));
2316   }
2317 };
2318
2319 // Arity 7 -> 3.
2320 template <typename StorageType, typename R,typename X1, typename X2,
2321     typename X3, typename X4, typename X5, typename X6, typename X7>
2322 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2323   typedef R(RunType)(BindStateBase*,
2324       typename CallbackParamTraits<X5>::ForwardType,
2325       typename CallbackParamTraits<X6>::ForwardType,
2326       typename CallbackParamTraits<X7>::ForwardType);
2327
2328   typedef R(UnboundRunType)(X5, X6, X7);
2329
2330   static R Run(BindStateBase* base,
2331       typename CallbackParamTraits<X5>::ForwardType x5,
2332       typename CallbackParamTraits<X6>::ForwardType x6,
2333       typename CallbackParamTraits<X7>::ForwardType x7) {
2334     StorageType* storage = static_cast<StorageType*>(base);
2335
2336     // Local references to make debugger stepping easier. If in a debugger,
2337     // you really want to warp ahead and step through the
2338     // InvokeHelper<>::MakeItSo() call below.
2339     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2340     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2341     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2342     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2343
2344     typename Bound1UnwrapTraits::ForwardType x1 =
2345         Bound1UnwrapTraits::Unwrap(storage->p1_);
2346     typename Bound2UnwrapTraits::ForwardType x2 =
2347         Bound2UnwrapTraits::Unwrap(storage->p2_);
2348     typename Bound3UnwrapTraits::ForwardType x3 =
2349         Bound3UnwrapTraits::Unwrap(storage->p3_);
2350     typename Bound4UnwrapTraits::ForwardType x4 =
2351         Bound4UnwrapTraits::Unwrap(storage->p4_);
2352     return InvokeHelper<StorageType::IsWeakCall::value, R,
2353            typename StorageType::RunnableType,
2354            void(typename Bound1UnwrapTraits::ForwardType,
2355                typename Bound2UnwrapTraits::ForwardType,
2356                typename Bound3UnwrapTraits::ForwardType,
2357                typename Bound4UnwrapTraits::ForwardType,
2358                typename CallbackParamTraits<X5>::ForwardType x5,
2359                typename CallbackParamTraits<X6>::ForwardType x6,
2360                typename CallbackParamTraits<X7>::ForwardType x7)>
2361                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2362                    CallbackForward(x2), CallbackForward(x3),
2363                    CallbackForward(x4), CallbackForward(x5),
2364                    CallbackForward(x6), CallbackForward(x7));
2365   }
2366 };
2367
2368 // Arity 7 -> 2.
2369 template <typename StorageType, typename R,typename X1, typename X2,
2370     typename X3, typename X4, typename X5, typename X6, typename X7>
2371 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2372   typedef R(RunType)(BindStateBase*,
2373       typename CallbackParamTraits<X6>::ForwardType,
2374       typename CallbackParamTraits<X7>::ForwardType);
2375
2376   typedef R(UnboundRunType)(X6, X7);
2377
2378   static R Run(BindStateBase* base,
2379       typename CallbackParamTraits<X6>::ForwardType x6,
2380       typename CallbackParamTraits<X7>::ForwardType x7) {
2381     StorageType* storage = static_cast<StorageType*>(base);
2382
2383     // Local references to make debugger stepping easier. If in a debugger,
2384     // you really want to warp ahead and step through the
2385     // InvokeHelper<>::MakeItSo() call below.
2386     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2387     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2388     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2389     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2390     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2391
2392     typename Bound1UnwrapTraits::ForwardType x1 =
2393         Bound1UnwrapTraits::Unwrap(storage->p1_);
2394     typename Bound2UnwrapTraits::ForwardType x2 =
2395         Bound2UnwrapTraits::Unwrap(storage->p2_);
2396     typename Bound3UnwrapTraits::ForwardType x3 =
2397         Bound3UnwrapTraits::Unwrap(storage->p3_);
2398     typename Bound4UnwrapTraits::ForwardType x4 =
2399         Bound4UnwrapTraits::Unwrap(storage->p4_);
2400     typename Bound5UnwrapTraits::ForwardType x5 =
2401         Bound5UnwrapTraits::Unwrap(storage->p5_);
2402     return InvokeHelper<StorageType::IsWeakCall::value, R,
2403            typename StorageType::RunnableType,
2404            void(typename Bound1UnwrapTraits::ForwardType,
2405                typename Bound2UnwrapTraits::ForwardType,
2406                typename Bound3UnwrapTraits::ForwardType,
2407                typename Bound4UnwrapTraits::ForwardType,
2408                typename Bound5UnwrapTraits::ForwardType,
2409                typename CallbackParamTraits<X6>::ForwardType x6,
2410                typename CallbackParamTraits<X7>::ForwardType x7)>
2411                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2412                    CallbackForward(x2), CallbackForward(x3),
2413                    CallbackForward(x4), CallbackForward(x5),
2414                    CallbackForward(x6), CallbackForward(x7));
2415   }
2416 };
2417
2418 // Arity 7 -> 1.
2419 template <typename StorageType, typename R,typename X1, typename X2,
2420     typename X3, typename X4, typename X5, typename X6, typename X7>
2421 struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2422   typedef R(RunType)(BindStateBase*,
2423       typename CallbackParamTraits<X7>::ForwardType);
2424
2425   typedef R(UnboundRunType)(X7);
2426
2427   static R Run(BindStateBase* base,
2428       typename CallbackParamTraits<X7>::ForwardType x7) {
2429     StorageType* storage = static_cast<StorageType*>(base);
2430
2431     // Local references to make debugger stepping easier. If in a debugger,
2432     // you really want to warp ahead and step through the
2433     // InvokeHelper<>::MakeItSo() call below.
2434     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2435     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2436     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2437     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2438     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2439     typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2440
2441     typename Bound1UnwrapTraits::ForwardType x1 =
2442         Bound1UnwrapTraits::Unwrap(storage->p1_);
2443     typename Bound2UnwrapTraits::ForwardType x2 =
2444         Bound2UnwrapTraits::Unwrap(storage->p2_);
2445     typename Bound3UnwrapTraits::ForwardType x3 =
2446         Bound3UnwrapTraits::Unwrap(storage->p3_);
2447     typename Bound4UnwrapTraits::ForwardType x4 =
2448         Bound4UnwrapTraits::Unwrap(storage->p4_);
2449     typename Bound5UnwrapTraits::ForwardType x5 =
2450         Bound5UnwrapTraits::Unwrap(storage->p5_);
2451     typename Bound6UnwrapTraits::ForwardType x6 =
2452         Bound6UnwrapTraits::Unwrap(storage->p6_);
2453     return InvokeHelper<StorageType::IsWeakCall::value, R,
2454            typename StorageType::RunnableType,
2455            void(typename Bound1UnwrapTraits::ForwardType,
2456                typename Bound2UnwrapTraits::ForwardType,
2457                typename Bound3UnwrapTraits::ForwardType,
2458                typename Bound4UnwrapTraits::ForwardType,
2459                typename Bound5UnwrapTraits::ForwardType,
2460                typename Bound6UnwrapTraits::ForwardType,
2461                typename CallbackParamTraits<X7>::ForwardType x7)>
2462                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2463                    CallbackForward(x2), CallbackForward(x3),
2464                    CallbackForward(x4), CallbackForward(x5),
2465                    CallbackForward(x6), CallbackForward(x7));
2466   }
2467 };
2468
2469 // Arity 7 -> 0.
2470 template <typename StorageType, typename R,typename X1, typename X2,
2471     typename X3, typename X4, typename X5, typename X6, typename X7>
2472 struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
2473   typedef R(RunType)(BindStateBase*);
2474
2475   typedef R(UnboundRunType)();
2476
2477   static R Run(BindStateBase* base) {
2478     StorageType* storage = static_cast<StorageType*>(base);
2479
2480     // Local references to make debugger stepping easier. If in a debugger,
2481     // you really want to warp ahead and step through the
2482     // InvokeHelper<>::MakeItSo() call below.
2483     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
2484     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
2485     typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
2486     typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
2487     typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
2488     typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
2489     typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits;
2490
2491     typename Bound1UnwrapTraits::ForwardType x1 =
2492         Bound1UnwrapTraits::Unwrap(storage->p1_);
2493     typename Bound2UnwrapTraits::ForwardType x2 =
2494         Bound2UnwrapTraits::Unwrap(storage->p2_);
2495     typename Bound3UnwrapTraits::ForwardType x3 =
2496         Bound3UnwrapTraits::Unwrap(storage->p3_);
2497     typename Bound4UnwrapTraits::ForwardType x4 =
2498         Bound4UnwrapTraits::Unwrap(storage->p4_);
2499     typename Bound5UnwrapTraits::ForwardType x5 =
2500         Bound5UnwrapTraits::Unwrap(storage->p5_);
2501     typename Bound6UnwrapTraits::ForwardType x6 =
2502         Bound6UnwrapTraits::Unwrap(storage->p6_);
2503     typename Bound7UnwrapTraits::ForwardType x7 =
2504         Bound7UnwrapTraits::Unwrap(storage->p7_);
2505     return InvokeHelper<StorageType::IsWeakCall::value, R,
2506            typename StorageType::RunnableType,
2507            void(typename Bound1UnwrapTraits::ForwardType,
2508                typename Bound2UnwrapTraits::ForwardType,
2509                typename Bound3UnwrapTraits::ForwardType,
2510                typename Bound4UnwrapTraits::ForwardType,
2511                typename Bound5UnwrapTraits::ForwardType,
2512                typename Bound6UnwrapTraits::ForwardType,
2513                typename Bound7UnwrapTraits::ForwardType)>
2514                ::MakeItSo(storage->runnable_, CallbackForward(x1),
2515                    CallbackForward(x2), CallbackForward(x3),
2516                    CallbackForward(x4), CallbackForward(x5),
2517                    CallbackForward(x6), CallbackForward(x7));
2518   }
2519 };
2520
2521
2522 // BindState<>
2523 //
2524 // This stores all the state passed into Bind() and is also where most
2525 // of the template resolution magic occurs.
2526 //
2527 // Runnable is the functor we are binding arguments to.
2528 // RunType is type of the Run() function that the Invoker<> should use.
2529 // Normally, this is the same as the RunType of the Runnable, but it can
2530 // be different if an adapter like IgnoreResult() has been used.
2531 //
2532 // BoundArgsType contains the storage type for all the bound arguments by
2533 // (ab)using a function type.
2534 template <typename Runnable, typename RunType, typename BoundArgsType>
2535 struct BindState;
2536
2537 template <typename Runnable, typename RunType>
2538 struct BindState<Runnable, RunType, void()> : public BindStateBase {
2539   typedef Runnable RunnableType;
2540   typedef false_type IsWeakCall;
2541   typedef Invoker<0, BindState, RunType> InvokerType;
2542   typedef typename InvokerType::UnboundRunType UnboundRunType;
2543   explicit BindState(const Runnable& runnable)
2544       : runnable_(runnable) {
2545   }
2546
2547   virtual ~BindState() {  }
2548
2549   RunnableType runnable_;
2550 };
2551
2552 template <typename Runnable, typename RunType, typename P1>
2553 struct BindState<Runnable, RunType, void(P1)> : public BindStateBase {
2554   typedef Runnable RunnableType;
2555   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2556   typedef Invoker<1, BindState, RunType> InvokerType;
2557   typedef typename InvokerType::UnboundRunType UnboundRunType;
2558
2559   // Convenience typedefs for bound argument types.
2560   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2561
2562   BindState(const Runnable& runnable, const P1& p1)
2563       : runnable_(runnable),
2564         p1_(p1) {
2565     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2566   }
2567
2568   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2569       P1>::Release(p1_);  }
2570
2571   RunnableType runnable_;
2572   P1 p1_;
2573 };
2574
2575 template <typename Runnable, typename RunType, typename P1, typename P2>
2576 struct BindState<Runnable, RunType, void(P1, P2)> : public BindStateBase {
2577   typedef Runnable RunnableType;
2578   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2579   typedef Invoker<2, BindState, RunType> InvokerType;
2580   typedef typename InvokerType::UnboundRunType UnboundRunType;
2581
2582   // Convenience typedefs for bound argument types.
2583   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2584   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2585
2586   BindState(const Runnable& runnable, const P1& p1, const P2& p2)
2587       : runnable_(runnable),
2588         p1_(p1),
2589         p2_(p2) {
2590     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2591   }
2592
2593   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2594       P1>::Release(p1_);  }
2595
2596   RunnableType runnable_;
2597   P1 p1_;
2598   P2 p2_;
2599 };
2600
2601 template <typename Runnable, typename RunType, typename P1, typename P2,
2602     typename P3>
2603 struct BindState<Runnable, RunType, void(P1, P2, P3)> : public BindStateBase {
2604   typedef Runnable RunnableType;
2605   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2606   typedef Invoker<3, BindState, RunType> InvokerType;
2607   typedef typename InvokerType::UnboundRunType UnboundRunType;
2608
2609   // Convenience typedefs for bound argument types.
2610   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2611   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2612   typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2613
2614   BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3)
2615       : runnable_(runnable),
2616         p1_(p1),
2617         p2_(p2),
2618         p3_(p3) {
2619     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2620   }
2621
2622   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2623       P1>::Release(p1_);  }
2624
2625   RunnableType runnable_;
2626   P1 p1_;
2627   P2 p2_;
2628   P3 p3_;
2629 };
2630
2631 template <typename Runnable, typename RunType, typename P1, typename P2,
2632     typename P3, typename P4>
2633 struct BindState<Runnable, RunType, void(P1, P2, P3,
2634     P4)> : public BindStateBase {
2635   typedef Runnable RunnableType;
2636   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2637   typedef Invoker<4, BindState, RunType> InvokerType;
2638   typedef typename InvokerType::UnboundRunType UnboundRunType;
2639
2640   // Convenience typedefs for bound argument types.
2641   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2642   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2643   typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2644   typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2645
2646   BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2647       const P4& p4)
2648       : runnable_(runnable),
2649         p1_(p1),
2650         p2_(p2),
2651         p3_(p3),
2652         p4_(p4) {
2653     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2654   }
2655
2656   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2657       P1>::Release(p1_);  }
2658
2659   RunnableType runnable_;
2660   P1 p1_;
2661   P2 p2_;
2662   P3 p3_;
2663   P4 p4_;
2664 };
2665
2666 template <typename Runnable, typename RunType, typename P1, typename P2,
2667     typename P3, typename P4, typename P5>
2668 struct BindState<Runnable, RunType, void(P1, P2, P3, P4,
2669     P5)> : public BindStateBase {
2670   typedef Runnable RunnableType;
2671   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2672   typedef Invoker<5, BindState, RunType> InvokerType;
2673   typedef typename InvokerType::UnboundRunType UnboundRunType;
2674
2675   // Convenience typedefs for bound argument types.
2676   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2677   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2678   typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2679   typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2680   typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2681
2682   BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2683       const P4& p4, const P5& p5)
2684       : runnable_(runnable),
2685         p1_(p1),
2686         p2_(p2),
2687         p3_(p3),
2688         p4_(p4),
2689         p5_(p5) {
2690     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2691   }
2692
2693   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2694       P1>::Release(p1_);  }
2695
2696   RunnableType runnable_;
2697   P1 p1_;
2698   P2 p2_;
2699   P3 p3_;
2700   P4 p4_;
2701   P5 p5_;
2702 };
2703
2704 template <typename Runnable, typename RunType, typename P1, typename P2,
2705     typename P3, typename P4, typename P5, typename P6>
2706 struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5,
2707     P6)> : public BindStateBase {
2708   typedef Runnable RunnableType;
2709   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2710   typedef Invoker<6, BindState, RunType> InvokerType;
2711   typedef typename InvokerType::UnboundRunType UnboundRunType;
2712
2713   // Convenience typedefs for bound argument types.
2714   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2715   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2716   typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2717   typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2718   typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2719   typedef UnwrapTraits<P6> Bound6UnwrapTraits;
2720
2721   BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2722       const P4& p4, const P5& p5, const P6& p6)
2723       : runnable_(runnable),
2724         p1_(p1),
2725         p2_(p2),
2726         p3_(p3),
2727         p4_(p4),
2728         p5_(p5),
2729         p6_(p6) {
2730     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2731   }
2732
2733   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2734       P1>::Release(p1_);  }
2735
2736   RunnableType runnable_;
2737   P1 p1_;
2738   P2 p2_;
2739   P3 p3_;
2740   P4 p4_;
2741   P5 p5_;
2742   P6 p6_;
2743 };
2744
2745 template <typename Runnable, typename RunType, typename P1, typename P2,
2746     typename P3, typename P4, typename P5, typename P6, typename P7>
2747 struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6,
2748     P7)> : public BindStateBase {
2749   typedef Runnable RunnableType;
2750   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
2751   typedef Invoker<7, BindState, RunType> InvokerType;
2752   typedef typename InvokerType::UnboundRunType UnboundRunType;
2753
2754   // Convenience typedefs for bound argument types.
2755   typedef UnwrapTraits<P1> Bound1UnwrapTraits;
2756   typedef UnwrapTraits<P2> Bound2UnwrapTraits;
2757   typedef UnwrapTraits<P3> Bound3UnwrapTraits;
2758   typedef UnwrapTraits<P4> Bound4UnwrapTraits;
2759   typedef UnwrapTraits<P5> Bound5UnwrapTraits;
2760   typedef UnwrapTraits<P6> Bound6UnwrapTraits;
2761   typedef UnwrapTraits<P7> Bound7UnwrapTraits;
2762
2763   BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
2764       const P4& p4, const P5& p5, const P6& p6, const P7& p7)
2765       : runnable_(runnable),
2766         p1_(p1),
2767         p2_(p2),
2768         p3_(p3),
2769         p4_(p4),
2770         p5_(p5),
2771         p6_(p6),
2772         p7_(p7) {
2773     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
2774   }
2775
2776   virtual ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
2777       P1>::Release(p1_);  }
2778
2779   RunnableType runnable_;
2780   P1 p1_;
2781   P2 p2_;
2782   P3 p3_;
2783   P4 p4_;
2784   P5 p5_;
2785   P6 p6_;
2786   P7 p7_;
2787 };
2788
2789 }  // namespace internal
2790 }  // namespace base
2791
2792 #endif  // BASE_BIND_INTERNAL_H_