Callback API Change: Reimplement Bind(); support IgnoreResult, full currying, and use less types.

The main API change IgnoreResult() and fully currying.  See unittest for what the new API looks like.  The rest of the changes are done to support that.

Previously, IgnoreReturn could not be used with WeakPtr<> Bind()s as it was applied after the fact to the Callback object.  Now, IgnoreResult() wraps the function like Unretained().

As an incidental benefit, the new implementation gave us fully currying for free.

Also, the new implementation scales better when supporting higher arities of functions.  The new type growth is:

  (n^2 + 20n) / 2

as opposed to

  (3n^2 + 17n) / 2

where n == arity.

For n = 6 and n=10, the new implementation has 81 and 155 templates respectively.

The old implementation had 105 and 235 templates respectively.

BUG=35233,98919,98542
TEST=existing unittests

Review URL: http://codereview.chromium.org/8483003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@110975 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 239 insertions, 149 deletions

diff --git a/base/bind_internal_win.h b/base/bind_internal_win.h
index 250f472..17d3aa3 100644
--- a/base/bind_internal_win.h
+++ b/base/bind_internal_win.h
@@ -8,7 +8,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Specializations of FunctionTraits<> for Windows specific calling
+// Specializations of RunnableAdapter<> for Windows specific calling
 // conventions.  Please see base/bind_internal.h for more info.
 
 #ifndef BASE_BIND_INTERNAL_WIN_H_
@@ -23,203 +23,293 @@
 namespace base {
 namespace internal {
 
-template <typename Sig>
-struct FunctionTraits;
+template <typename Functor>
+class RunnableAdapter;
 
 // __stdcall Function: Arity 0.
 template <typename R>
-struct FunctionTraits<R(__stdcall *)()> {
-  typedef R (*NormalizedSig)();
-  typedef false_type IsMethod;
+class RunnableAdapter<R(__stdcall *)()> {
+ public:
+  typedef R (RunType)();
 
-  typedef R Return;
+  explicit RunnableAdapter(R(__stdcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (__stdcall *function_)();
 };
 
 // __fastcall Function: Arity 0.
 template <typename R>
-struct FunctionTraits<R(__fastcall *)()> {
-  typedef R (*NormalizedSig)();
-  typedef false_type IsMethod;
+class RunnableAdapter<R(__fastcall *)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(__fastcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
 
-  typedef R Return;
+ private:
+  R (__fastcall *function_)();
 };
 
 // __stdcall Function: Arity 1.
-template <typename R, typename X1>
-struct FunctionTraits<R(__stdcall *)(X1)> {
-  typedef R (*NormalizedSig)(X1);
-  typedef false_type IsMethod;
+template <typename R, typename A1>
+class RunnableAdapter<R(__stdcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
 
-  typedef R Return;
+  explicit RunnableAdapter(R(__stdcall *function)(A1))
+      : function_(function) {
+  }
 
-  // Target type for each bound parameter.
-  typedef X1 B1;
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
+
+ private:
+  R (__stdcall *function_)(A1);
 };
 
 // __fastcall Function: Arity 1.
-template <typename R, typename X1>
-struct FunctionTraits<R(__fastcall *)(X1)> {
-  typedef R (*NormalizedSig)(X1);
-  typedef false_type IsMethod;
+template <typename R, typename A1>
+class RunnableAdapter<R(__fastcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1))
+      : function_(function) {
+  }
 
-  typedef R Return;
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
 
-  // Target type for each bound parameter.
-  typedef X1 B1;
+ private:
+  R (__fastcall *function_)(A1);
 };
 
 // __stdcall Function: Arity 2.
-template <typename R, typename X1, typename X2>
-struct FunctionTraits<R(__stdcall *)(X1, X2)> {
-  typedef R (*NormalizedSig)(X1, X2);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__stdcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2);
 };
 
 // __fastcall Function: Arity 2.
-template <typename R, typename X1, typename X2>
-struct FunctionTraits<R(__fastcall *)(X1, X2)> {
-  typedef R (*NormalizedSig)(X1, X2);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__fastcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2);
 };
 
 // __stdcall Function: Arity 3.
-template <typename R, typename X1, typename X2, typename X3>
-struct FunctionTraits<R(__stdcall *)(X1, X2, X3)> {
-  typedef R (*NormalizedSig)(X1, X2, X3);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3);
 };
 
 // __fastcall Function: Arity 3.
-template <typename R, typename X1, typename X2, typename X3>
-struct FunctionTraits<R(__fastcall *)(X1, X2, X3)> {
-  typedef R (*NormalizedSig)(X1, X2, X3);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3);
 };
 
 // __stdcall Function: Arity 4.
-template <typename R, typename X1, typename X2, typename X3, typename X4>
-struct FunctionTraits<R(__stdcall *)(X1, X2, X3, X4)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4);
 };
 
 // __fastcall Function: Arity 4.
-template <typename R, typename X1, typename X2, typename X3, typename X4>
-struct FunctionTraits<R(__fastcall *)(X1, X2, X3, X4)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4);
 };
 
 // __stdcall Function: Arity 5.
-template <typename R, typename X1, typename X2, typename X3, typename X4,
-    typename X5>
-struct FunctionTraits<R(__stdcall *)(X1, X2, X3, X4, X5)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4, X5);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
-  typedef X5 B5;
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5);
 };
 
 // __fastcall Function: Arity 5.
-template <typename R, typename X1, typename X2, typename X3, typename X4,
-    typename X5>
-struct FunctionTraits<R(__fastcall *)(X1, X2, X3, X4, X5)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4, X5);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
-  typedef X5 B5;
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5);
 };
 
 // __stdcall Function: Arity 6.
-template <typename R, typename X1, typename X2, typename X3, typename X4,
-    typename X5, typename X6>
-struct FunctionTraits<R(__stdcall *)(X1, X2, X3, X4, X5, X6)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4, X5, X6);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
-  typedef X5 B5;
-  typedef X6 B6;
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6);
 };
 
 // __fastcall Function: Arity 6.
-template <typename R, typename X1, typename X2, typename X3, typename X4,
-    typename X5, typename X6>
-struct FunctionTraits<R(__fastcall *)(X1, X2, X3, X4, X5, X6)> {
-  typedef R (*NormalizedSig)(X1, X2, X3, X4, X5, X6);
-  typedef false_type IsMethod;
-
-  typedef R Return;
-
-  // Target type for each bound parameter.
-  typedef X1 B1;
-  typedef X2 B2;
-  typedef X3 B3;
-  typedef X4 B4;
-  typedef X5 B5;
-  typedef X6 B6;
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6);
 };
 
 }  // namespace internal