Unified callback system.

base/prebind.h

Index: base/prebind.h
diff --git a/base/prebind.h b/base/prebind.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfb22a9632c99acc3deca8f8b38d24874b4db0a4
--- /dev/null
+++ b/base/prebind.h
@@ -0,0 +1,1035 @@
+// This file was GENERATED by command:
+//     pump.py prebind.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PREBIND_H_
+#define BASE_PREBIND_H_
+
+#include "base/uber_callback.h"
+
+namespace base {
+
+namespace internal {
+// These classes are argument wrappers that affect the refcounting, and storage
+// semantics for prebound arguments.
+
+template <typename T>
+class UnretainedWrapper {
+ public:
+  explicit UnretainedWrapper(T* o) : obj_(o) {}
+  T* get() { return obj_; }
+ private:
+  T* obj_;
+};
+
+template <typename T>
+class ConstRefWrapper {
+ public:
+  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
+  const T* get() { return ptr_; }
+ private:
+  const T* ptr_;
+};
+
+// Unwrap for the wrappers above.
+template <typename T>
+T Unwrap(T o) { return o; }
+
+template <typename T>
+T* Unwrap(UnretainedWrapper<T> unretained) { return unretained.get(); }
+
+template <typename T>
+const T* Unwrap(ConstRefWrapper<T> const_ref) { return const_ref.get(); }
+
+// Optional Refcounting.
+
+template <bool ref, typename O>
+struct MaybeRefcount;
+
+template <typename O>
+struct MaybeRefcount<false, O> {
+  static void AddRef(const O&) {}
+  static void Release(const O&) {}
+};
+
+template <typename O>
+struct MaybeRefcount<true, UnretainedWrapper<O> > {
+  static void AddRef(const UnretainedWrapper<O>&) {}
+  static void Release(const UnretainedWrapper<O>&) {}
+};
+
+template <typename O>
+struct MaybeRefcount<true, ConstRefWrapper<O> > {
+  static void AddRef(ConstRefWrapper<O> o) { o.get()->AddRef(); }
+  static void Release(ConstRefWrapper<O> o) { o.get()->Release(); }
+};
+
+template <typename O>
+struct MaybeRefcount<true, O* > {
+  static void AddRef(O* o) { o->AddRef(); }
+  static void Release(O* o) { o->Release(); }
+};
+
+// The method by which a function is invoked is determined by 3 different
+// dimensions:
+//
+//   1) The type of function (normal, method, const-method)
+//   2) The arity of the function
+//   3) The number of bound parameters.
+//
+// The FunctionTraitsN classes unwrap the function signature type to
+// specialize based on the first two dimensions.  The N in FunctionTraitsN
+// specifies the 3rd dimension.
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits1;
+
+// Function: Arity 1 -> 0.
+template <typename StorageType, typename R, typename X1>
+struct FunctionTraits1<StorageType, R(*)(X1)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_));
+  }
+};
+
+// Method: Arity 0 -> 0.
+template <typename StorageType, typename R, typename T>
+struct FunctionTraits1<StorageType, R(T::*)()> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)();
+  }
+};
+
+// Const Method: Arity 0 -> 0.
+template <typename StorageType, typename R, typename T>
+struct FunctionTraits1<StorageType, R(T::*)() const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)();
+  }
+};
+
+// Function: Arity 2 -> 1.
+template <typename StorageType, typename R, typename X1, typename X2>
+struct FunctionTraits1<StorageType, R(*)(X1, X2)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), x2);
+  }
+};
+
+// Method: Arity 1 -> 1.
+template <typename StorageType, typename R, typename T, typename X1>
+struct FunctionTraits1<StorageType, R(T::*)(X1)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1);
+  }
+};
+
+// Const Method: Arity 1 -> 1.
+template <typename StorageType, typename R, typename T, typename X1>
+struct FunctionTraits1<StorageType, R(T::*)(X1) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1);
+  }
+};
+
+// Function: Arity 3 -> 2.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3>
+struct FunctionTraits1<StorageType, R(*)(X1, X2, X3)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), x2, x3);
+  }
+};
+
+// Method: Arity 2 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2);
+  }
+};
+
+// Const Method: Arity 2 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2);
+  }
+};
+
+// Function: Arity 4 -> 3.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4>
+struct FunctionTraits1<StorageType, R(*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), x2, x3, x4);
+  }
+};
+
+// Method: Arity 3 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3);
+  }
+};
+
+// Const Method: Arity 3 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3);
+  }
+};
+
+// Function: Arity 5 -> 4.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct FunctionTraits1<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), x2, x3, x4, x5);
+  }
+};
+
+// Method: Arity 4 -> 4.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3, x4);
+  }
+};
+
+// Const Method: Arity 4 -> 4.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3, X4) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3, x4);
+  }
+};
+
+// Function: Arity 6 -> 5.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits1<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4, X5 x5,
+      X6 x6) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), x2, x3, x4, x5, x6);
+  }
+};
+
+// Method: Arity 5 -> 5.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3, X4 x4,
+      X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3, x4, x5);
+  }
+};
+
+// Const Method: Arity 5 -> 5.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits1<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X1 x1, X2 x2, X3 x3, X4 x4,
+      X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(x1, x2, x3, x4, x5);
+  }
+};
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits2;
+
+// Function: Arity 2 -> 0.
+template <typename StorageType, typename R, typename X1, typename X2>
+struct FunctionTraits2<StorageType, R(*)(X1, X2)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_));
+  }
+};
+
+// Method: Arity 1 -> 0.
+template <typename StorageType, typename R, typename T, typename X1>
+struct FunctionTraits2<StorageType, R(T::*)(X1)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_));
+  }
+};
+
+// Const Method: Arity 1 -> 0.
+template <typename StorageType, typename R, typename T, typename X1>
+struct FunctionTraits2<StorageType, R(T::*)(X1) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_));
+  }
+};
+
+// Function: Arity 3 -> 1.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3>
+struct FunctionTraits2<StorageType, R(*)(X1, X2, X3)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_), x3);
+  }
+};
+
+// Method: Arity 2 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2);
+  }
+};
+
+// Const Method: Arity 2 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2);
+  }
+};
+
+// Function: Arity 4 -> 2.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4>
+struct FunctionTraits2<StorageType, R(*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_), x3, x4);
+  }
+};
+
+// Method: Arity 3 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3);
+  }
+};
+
+// Const Method: Arity 3 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3);
+  }
+};
+
+// Function: Arity 5 -> 3.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct FunctionTraits2<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_), x3, x4, x5);
+  }
+};
+
+// Method: Arity 4 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3,
+        x4);
+  }
+};
+
+// Const Method: Arity 4 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3, X4) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3,
+        x4);
+  }
+};
+
+// Function: Arity 6 -> 4.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits2<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4, X5 x5, X6 x6) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_), x3, x4, x5,
+        x6);
+  }
+};
+
+// Method: Arity 5 -> 4.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3,
+        x4, x5);
+  }
+};
+
+// Const Method: Arity 5 -> 4.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits2<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X2 x2, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_), x2, x3,
+        x4, x5);
+  }
+};
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits3;
+
+// Function: Arity 3 -> 0.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3>
+struct FunctionTraits3<StorageType, R(*)(X1, X2, X3)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_));
+  }
+};
+
+// Method: Arity 2 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_));
+  }
+};
+
+// Const Method: Arity 2 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_));
+  }
+};
+
+// Function: Arity 4 -> 1.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4>
+struct FunctionTraits3<StorageType, R(*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x4);
+  }
+};
+
+// Method: Arity 3 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3);
+  }
+};
+
+// Const Method: Arity 3 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3);
+  }
+};
+
+// Function: Arity 5 -> 2.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct FunctionTraits3<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x4, x5);
+  }
+};
+
+// Method: Arity 4 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3, x4);
+  }
+};
+
+// Const Method: Arity 4 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3, X4) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3, x4);
+  }
+};
+
+// Function: Arity 6 -> 3.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits3<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4, X5 x5, X6 x6) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x4, x5, x6);
+  }
+};
+
+// Method: Arity 5 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3, x4, x5);
+  }
+};
+
+// Const Method: Arity 5 -> 3.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits3<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X3 x3, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), x3, x4, x5);
+  }
+};
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits4;
+
+// Function: Arity 4 -> 0.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4>
+struct FunctionTraits4<StorageType, R(*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_));
+  }
+};
+
+// Method: Arity 3 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_));
+  }
+};
+
+// Const Method: Arity 3 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_));
+  }
+};
+
+// Function: Arity 5 -> 1.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct FunctionTraits4<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x5);
+  }
+};
+
+// Method: Arity 4 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x4);
+  }
+};
+
+// Const Method: Arity 4 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3, X4) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x4);
+  }
+};
+
+// Function: Arity 6 -> 2.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits4<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X5 x5, X6 x6) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x5, x6);
+  }
+};
+
+// Method: Arity 5 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x4, x5);
+  }
+};
+
+// Const Method: Arity 5 -> 2.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits4<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X4 x4, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), x4, x5);
+  }
+};
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits5;
+
+// Function: Arity 5 -> 0.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct FunctionTraits5<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_));
+  }
+};
+
+// Method: Arity 4 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits5<StorageType, R(T::*)(X1, X2, X3, X4)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_));
+  }
+};
+
+// Const Method: Arity 4 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4>
+struct FunctionTraits5<StorageType, R(T::*)(X1, X2, X3, X4) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_));
+  }
+};
+
+// Function: Arity 6 -> 1.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits5<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base, X6 x6) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_), x6);
+  }
+};
+
+// Method: Arity 5 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits5<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_), x5);
+  }
+};
+
+// Const Method: Arity 5 -> 1.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits5<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base, X5 x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_), x5);
+  }
+};
+
+template <typename StorageType, typename Sig>
+struct FunctionTraits6;
+
+// Function: Arity 6 -> 0.
+template <typename StorageType, typename R, typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct FunctionTraits6<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+  static const bool kShouldRef = false;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_),
+        Unwrap(invoker->p6_));
+  }
+};
+
+// Method: Arity 5 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits6<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_),
+        Unwrap(invoker->p6_));
+  }
+};
+
+// Const Method: Arity 5 -> 0.
+template <typename StorageType, typename R, typename T, typename X1,
+    typename X2, typename X3, typename X4, typename X5>
+struct FunctionTraits6<StorageType, R(T::*)(X1, X2, X3, X4, X5) const> {
+  static const bool kShouldRef = true;
+  static R DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
+        Unwrap(invoker->p3_), Unwrap(invoker->p4_), Unwrap(invoker->p5_),
+        Unwrap(invoker->p6_));
+  }
+};
+
+
+// These are the actual storage classes for the invokers.
+
+template <typename Sig, typename P1>
+class InvokerStorage1 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage1 StorageType;
+  typedef FunctionTraits1<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage1(Sig f, const P1& p1)
+      : f_(f), p1_(p1) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage1() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+};
+
+template <typename Sig, typename P1, typename P2>
+class InvokerStorage2 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage2 StorageType;
+  typedef FunctionTraits2<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage2(Sig f, const P1& p1, const P2& p2)
+      : f_(f), p1_(p1), p2_(p2) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage2() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+  P2 p2_;
+};
+
+template <typename Sig, typename P1, typename P2, typename P3>
+class InvokerStorage3 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage3 StorageType;
+  typedef FunctionTraits3<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage3(Sig f, const P1& p1, const P2& p2, const P3& p3)
+      : f_(f), p1_(p1), p2_(p2), p3_(p3) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage3() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+};
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4>
+class InvokerStorage4 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage4 StorageType;
+  typedef FunctionTraits4<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage4(Sig f, const P1& p1, const P2& p2, const P3& p3, const P4& p4)
+      : f_(f), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage4() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+};
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+class InvokerStorage5 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage5 StorageType;
+  typedef FunctionTraits5<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage5(Sig f, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5)
+      : f_(f), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage5() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+};
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6>
+class InvokerStorage6 : public InvokerStorageBase {
+ public:
+  typedef InvokerStorage6 StorageType;
+  typedef FunctionTraits6<StorageType, Sig> FunctionTraits;
+
+  InvokerStorage6(Sig f, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5, const P6& p6)
+      : f_(f), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::AddRef(p1_);
+  }
+
+  virtual ~InvokerStorage6() {
+    MaybeRefcount<FunctionTraits::kShouldRef, P1>::Release(p1_);
+  }
+
+  Sig f_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 p6_;
+};
+
+}  // namespace internal
+
+
+template <typename Sig, typename P1>
+InvokerStorageHolder<internal::InvokerStorage1<Sig, P1> >
+Prebind(Sig f, const P1& p1) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage1<Sig, P1>(
+          f,  p1));
+}
+
+template <typename Sig, typename P1, typename P2>
+InvokerStorageHolder<internal::InvokerStorage2<Sig, P1, P2> >
+Prebind(Sig f, const P1& p1, const P2& p2) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage2<Sig, P1, P2>(
+          f,  p1, p2));
+}
+
+template <typename Sig, typename P1, typename P2, typename P3>
+InvokerStorageHolder<internal::InvokerStorage3<Sig, P1, P2, P3> >
+Prebind(Sig f, const P1& p1, const P2& p2, const P3& p3) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage3<Sig, P1, P2, P3>(
+          f,  p1, p2, p3));
+}
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4>
+InvokerStorageHolder<internal::InvokerStorage4<Sig, P1, P2, P3, P4> >
+Prebind(Sig f, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage4<Sig, P1, P2, P3, P4>(
+          f,  p1, p2, p3, p4));
+}
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+InvokerStorageHolder<internal::InvokerStorage5<Sig, P1, P2, P3, P4, P5> >
+Prebind(Sig f, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage5<Sig, P1, P2, P3, P4, P5>(
+          f,  p1, p2, p3, p4, p5));
+}
+
+template <typename Sig, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6>
+InvokerStorageHolder<internal::InvokerStorage6<Sig, P1, P2, P3, P4, P5, P6> >
+Prebind(Sig f, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5, const P6& p6) {
+  return MakeInvokerStorageHolder(
+      new internal::InvokerStorage6<Sig, P1, P2, P3, P4, P5, P6>(
+          f,  p1, p2, p3, p4, p5, p6));
+}
+
+template <typename T>
+inline internal::UnretainedWrapper<T> Unretained(T* o) {
+  return internal::UnretainedWrapper<T>(o);
+}
+
+template <typename T>
+inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
+  return internal::ConstRefWrapper<T>(o);
+}
+
+
+}  // namespace base
+
+#endif  // BASE_PREBIND_H_