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

base/bind_unittest.cc

 // 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.
 
 #include "base/bind.h"
 
 #include "base/callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 242 matching lines @@
   Callback<int(int,int,int,int)> c4 = Bind(&Sum, 32, 16);
   EXPECT_EQ(94, c4.Run(13, 12, 11, 10));
 
   Callback<int(int,int,int,int,int)> c5 = Bind(&Sum, 32);
   EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9));
 
   Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum);
   EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14));
 }
 
-// Bind should be able to take existing Callbacks and convert to a Closure.
-TEST_F(BindTest, CallbackBindMore) {
-  int output = 0;
-  Closure c;
+// Test the Currying ability of the Callback system.
+TEST_F(BindTest, CurryingTest) {
+  Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum);
+  EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14));
 
-  Callback<void(int)> c1 = Bind(&OutputSum, &output, 16, 8, 4, 2);
-  c = Bind(c1, 10);
-  c.Run();
-  EXPECT_EQ(40, output);
+  Callback<int(int,int,int,int,int)> c5 = Bind(c6, 32);
+  EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9));
 
-  Callback<void(int,int)> c2 = Bind(&OutputSum, &output, 16, 8, 4);
-  c = Bind(c2, 10, 9);
-  c.Run();
-  EXPECT_EQ(47, output);
+  Callback<int(int,int,int,int)> c4 = Bind(c5, 16);
+  EXPECT_EQ(94, c4.Run(13, 12, 11, 10));
 
-  Callback<void(int,int,int)> c3 = Bind(&OutputSum, &output, 16, 8);
-  c = Bind(c3, 10, 9, 8);
-  c.Run();
-  EXPECT_EQ(51, output);
+  Callback<int(int,int,int)> c3 = Bind(c4, 8);
+  EXPECT_EQ(92, c3.Run(13, 12, 11));
 
-  Callback<void(int,int,int,int)> c4 = Bind(&OutputSum, &output, 16);
-  c = Bind(c4, 10, 9, 8, 7);
-  c.Run();
-  EXPECT_EQ(50, output);
+  Callback<int(int,int)> c2 = Bind(c3, 4);
+  EXPECT_EQ(85, c2.Run(13, 12));
 
-  Callback<void(int,int,int,int,int)> c5 = Bind(&OutputSum, &output);
-  c = Bind(c5, 10, 9, 8, 7, 6);
-  c.Run();
-  EXPECT_EQ(40, output);
+  Callback<int(int)> c1 = Bind(c2, 2);
+  EXPECT_EQ(75, c1.Run(13));
+
+  Callback<int(void)> c0 = Bind(c1, 1);
+  EXPECT_EQ(63, c0.Run());
 }
 
 // Function type support.
 //   - Normal function.
 //   - Normal function bound with non-refcounted first argument.
 //   - Method bound to non-const object.
 //   - Method bound to scoped_refptr.
 //   - Const method bound to non-const object.
 //   - Const method bound to const object.
 //   - Derived classes can be used with pointers to non-virtual base functions.
@@ skipping 54 matching lines @@
   Callback<int(void)> const_method_nonconst_obj_cb =
       Bind(&HasRef::IntConstMethod0, &has_ref_);
   Callback<int(void)> const_method_const_obj_cb =
       Bind(&HasRef::IntConstMethod0, const_has_ref_ptr_);
   EXPECT_EQ(1337, normal_cb.Run());
   EXPECT_EQ(31337, method_cb.Run());
   EXPECT_EQ(41337, const_method_nonconst_obj_cb.Run());
   EXPECT_EQ(51337, const_method_const_obj_cb.Run());
 }
 
-// IgnoreReturn adapter test.
-//   - Function with return value, and no params can be converted to Closure.
-TEST_F(BindTest, IgnoreReturn) {
+// IgnoreResult adapter test.
+//   - Function with return value.
+//   - Method with return value.
+//   - Const Method with return.
+//   - Method with return value bound to WeakPtr<>.
+//   - Const Method with return bound to WeakPtr<>.
+TEST_F(BindTest, IgnoreResult) {
   EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
-  Callback<int(void)> normal_cb = Bind(&IntFunc0);
-  Closure c = IgnoreReturn(normal_cb);
-  c.Run();
+  EXPECT_CALL(has_ref_, AddRef()).Times(2);
+  EXPECT_CALL(has_ref_, Release()).Times(2);
+  EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(10));
+  EXPECT_CALL(has_ref_, IntConstMethod0()).WillOnce(Return(11));
+  EXPECT_CALL(no_ref_, IntMethod0()).WillOnce(Return(12));
+  EXPECT_CALL(no_ref_, IntConstMethod0()).WillOnce(Return(13));
+
+  Closure normal_func_cb = Bind(IgnoreResult(&IntFunc0));
+  normal_func_cb.Run();
+
+  Closure non_void_method_cb =
+      Bind(IgnoreResult(&HasRef::IntMethod0), &has_ref_);
+  non_void_method_cb.Run();
+
+  Closure non_void_const_method_cb =
+      Bind(IgnoreResult(&HasRef::IntConstMethod0), &has_ref_);
+  non_void_const_method_cb.Run();
+
+  WeakPtrFactory<NoRef> weak_factory(&no_ref_);
+  WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
+
+  Closure non_void_weak_method_cb  =
+      Bind(IgnoreResult(&NoRef::IntMethod0), weak_factory.GetWeakPtr());
+  non_void_weak_method_cb.Run();
+
+  Closure non_void_weak_const_method_cb =
+      Bind(IgnoreResult(&NoRef::IntConstMethod0), weak_factory.GetWeakPtr());
+  non_void_weak_const_method_cb.Run();
+
+  weak_factory.InvalidateWeakPtrs();
+  non_void_weak_const_method_cb.Run();
+  non_void_weak_method_cb.Run();
 }
 
 // Argument binding tests.
 //   - Argument binding to primitive.
 //   - Argument binding to primitive pointer.
 //   - Argument binding to a literal integer.
 //   - Argument binding to a literal string.
 //   - Argument binding with template function.
 //   - Argument binding to an object.
 //   - Argument binding to pointer to incomplete type.
@@ skipping 63 matching lines @@
       Bind(&VoidPolymorphic1<const int&>);
   Callback<void(int[])> unbound_unsized_array_cb =
       Bind(&VoidPolymorphic1<int[]>);
   Callback<void(int[2])> unbound_sized_array_cb =
       Bind(&VoidPolymorphic1<int[2]>);
   Callback<void(int[][2])> unbound_array_of_arrays_cb =
       Bind(&VoidPolymorphic1<int[][2]>);
 }
 
 // Function with unbound reference parameter.
-//   - Original paraemter is modified by callback.
+//   - Original parameter is modified by callback.
 TEST_F(BindTest, UnboundReferenceSupport) {
   int n = 0;
   Callback<void(int&)> unbound_ref_cb = Bind(&RefArgSet);
   unbound_ref_cb.Run(n);
   EXPECT_EQ(2, n);
 }
 
 // Functions that take reference parameters.
 //  - Forced reference parameter type still stores a copy.
 //  - Forced const reference parameter type still stores a copy.
@@ skipping 80 matching lines @@
 //   - Const method bound to WeakPtr<> to const object.
 //   - Normal Function with WeakPtr<> as P1 can have return type and is
 //     not canceled.
 TEST_F(BindTest, WeakPtr) {
   EXPECT_CALL(no_ref_, VoidMethod0());
   EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
 
   WeakPtrFactory<NoRef> weak_factory(&no_ref_);
   WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
 
-  Callback<void(void)> method_cb =
+  Closure method_cb =
       Bind(&NoRef::VoidMethod0, weak_factory.GetWeakPtr());
   method_cb.Run();
 
-  Callback<void(void)> const_method_cb =
+  Closure const_method_cb =
       Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
   const_method_cb.Run();
 
-  Callback<void(void)> const_method_const_ptr_cb =
+  Closure const_method_const_ptr_cb =
       Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
   const_method_const_ptr_cb.Run();
 
   Callback<int(int)> normal_func_cb =
       Bind(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr());
   EXPECT_EQ(1, normal_func_cb.Run(1));
 
   weak_factory.InvalidateWeakPtrs();
   const_weak_factory.InvalidateWeakPtrs();
 
@@ skipping 111 matching lines @@
   Callback<int(void)> fastcall_cb = Bind(&FastCallFunc, 1);
   EXPECT_EQ(1, fastcall_cb.Run());
 
   Callback<int(void)> stdcall_cb = Bind(&StdCallFunc, 2);
   EXPECT_EQ(2, stdcall_cb.Run());
 }
 #endif
 
 }  // namespace
 }  // namespace base