Remove BindStateHolder and have Bind() return a Callback<> object directly.

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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 189 matching lines @@
 }
 
 int UnwrapNoRefParentConstRef(const NoRefParent& p) {
   return p.value;
 }
 
 void RefArgSet(int &n) {
   n = 2;
 }
 
+void PtrArgSet(int *n) {
+  *n = 2;
+}
+
 int FunctionWithWeakFirstParam(WeakPtr<NoRef> o, int n) {
   return n;
 }
 
+void TakesACallback(const Closure& callback) {
+  callback.Run();
+}
+
 class BindTest : public ::testing::Test {
  public:
   BindTest() {
     const_has_ref_ptr_ = &has_ref_;
     const_no_ref_ptr_ = &no_ref_;
     static_func_mock_ptr = &static_func_mock_;
   }
 
   virtual ~BindTest() {
   }
@@ skipping 61 matching lines @@
   Callback<int(int,int)> c2 = Bind(c3, 4);
   EXPECT_EQ(85, c2.Run(13, 12));
 
   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());
 }
 
+// Test that currying the rvalue result of another Bind() works correctly.
+//   - rvalue should be usable as argument to Bind().
+//   - multiple runs of resulting Callback remain valid.
+TEST_F(BindTest, CurryingRvalueResultOfBind) {
+  int n = 0;
+  Closure cb = base::Bind(&TakesACallback, base::Bind(&PtrArgSet, &n));
+
+  // If we implement Bind() such that the return value has auto_ptr-like
+  // semantics, the second call here will fail because ownership of
+  // the internal BindState<> would have been transfered to a *temporary*
+  // constructon of a Callback object on the first call.
+  cb.Run();
+  EXPECT_EQ(2, n);
+
+  n = 0;
+  cb.Run();
+  EXPECT_EQ(2, n);
+}
+
 // 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.
 //   - Derived classes can be used with pointers to virtual base functions (and
 //     preserve virtual dispatch).
@@ skipping 465 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