WIP: base::Bind for rvalue references.

base/bind_unittest.cc

 // Copyright (c) 2012 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 132 matching lines @@
   }
 
   void VoidMethod0() {}
 
  private:
   int* deletes_;
 };
 
 template <typename T>
 T PassThru(T scoper) {
-  return scoper.Pass();
+  return scoper;
 }
 
 // Some test functions that we can Bind to.
 template <typename T>
 T PolymorphicIdentity(T t) {
   return t;
 }
 
 template <typename T>
 void VoidPolymorphic1(T t) {
@@ skipping 156 matching lines @@
 //   - 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).
 TEST_F(BindTest, FunctionTypeSupport) {
   EXPECT_CALL(static_func_mock_, VoidMethod0());
-  EXPECT_CALL(has_ref_, AddRef()).Times(5);
-  EXPECT_CALL(has_ref_, Release()).Times(5);
+  EXPECT_CALL(has_ref_, AddRef()).Times(4);
+  EXPECT_CALL(has_ref_, Release()).Times(4);
   EXPECT_CALL(has_ref_, VoidMethod0()).Times(2);
   EXPECT_CALL(has_ref_, VoidConstMethod0()).Times(2);
 
   Closure normal_cb = Bind(&VoidFunc0);
   Callback<NoRef*(void)> normal_non_refcounted_cb =
       Bind(&PolymorphicIdentity<NoRef*>, &no_ref_);
   normal_cb.Run();
   EXPECT_EQ(&no_ref_, normal_non_refcounted_cb.Run());
 
   Closure method_cb = Bind(&HasRef::VoidMethod0, &has_ref_);
@@ skipping 366 matching lines @@
 //   - Passed() can be constructed from a scoper rvalue.
 //   - Using Passed() gives Callback Ownership.
 //   - Ownership is transferred from Callback to callee on the first Run().
 //   - Callback supports unbound arguments.
 TEST_F(BindTest, ScopedPtr) {
   int deletes = 0;
 
   // Tests the Passed() function's support for pointers.
   scoped_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes));
   Callback<scoped_ptr<DeleteCounter>(void)> unused_callback =
-      Bind(&PassThru<scoped_ptr<DeleteCounter> >, Passed(&ptr));
+      Bind(&PassThru<scoped_ptr<DeleteCounter>>, Passed(&ptr));
   EXPECT_FALSE(ptr.get());
   EXPECT_EQ(0, deletes);
 
   // If we never invoke the Callback, it retains ownership and deletes.
   unused_callback.Reset();
   EXPECT_EQ(1, deletes);
 
   // Tests the Passed() function's support for rvalues.
   deletes = 0;
   DeleteCounter* counter = new DeleteCounter(&deletes);
@@ skipping 16 matching lines @@
   result.reset();
   EXPECT_EQ(1, deletes);
 
   // Test unbound argument forwarding.
   Callback<scoped_ptr<DeleteCounter>(scoped_ptr<DeleteCounter>)> cb_unbound =
       Bind(&PassThru<scoped_ptr<DeleteCounter> >);
   ptr.reset(new DeleteCounter(&deletes));
   cb_unbound.Run(ptr.Pass());
 }
 
+// RValue support.
+//   - Bind() can take move-only values by RValue-reference.
+//   - Using an RValue gives Callback Ownership.
+//   - Ownership is transferred from Callback to callee on the first Run().
+//   - Callback supports unbound arguments.
+TEST_F(BindTest, ScopedPtrRValue) {
+  int deletes = 0;
+
+  // Tests the Passed() function's support for pointers.
+  scoped_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes));
+  Callback<scoped_ptr<DeleteCounter>(void)> unused_callback =
+      Bind(&PassThru<scoped_ptr<DeleteCounter>>, std::move(ptr));
+  EXPECT_FALSE(ptr.get());
+  EXPECT_EQ(0, deletes);
+
+  // If we never invoke the Callback, it retains ownership and deletes.
+  unused_callback.Reset();
+  EXPECT_EQ(1, deletes);
+
+  // Tests the Passed() function's support for rvalues.
+  deletes = 0;
+  DeleteCounter* counter = new DeleteCounter(&deletes);
+  Callback<scoped_ptr<DeleteCounter>(void)> callback =
+      Bind(&PassThru<scoped_ptr<DeleteCounter> >,
+           scoped_ptr<DeleteCounter>(counter));
+  EXPECT_FALSE(ptr.get());
+  EXPECT_EQ(0, deletes);
+
+  // Check that ownership can be transferred back out.
+  scoped_ptr<DeleteCounter> result = callback.Run();
+  ASSERT_EQ(counter, result.get());
+  EXPECT_EQ(0, deletes);
+
+  // Resetting does not delete since ownership was transferred.
+  callback.Reset();
+  EXPECT_EQ(0, deletes);
+
+  // Ensure that we actually did get ownership.
+  result.reset();
+  EXPECT_EQ(1, deletes);
+
+  // Test unbound argument forwarding.
+  Callback<scoped_ptr<DeleteCounter>(scoped_ptr<DeleteCounter>)> cb_unbound =
+      Bind(&PassThru<scoped_ptr<DeleteCounter> >);
+  ptr.reset(new DeleteCounter(&deletes));
+  cb_unbound.Run(std::move(ptr));
+}
+
+// RValue support.
+//   - Bind() can take move-only values by RValue-reference.
+//   - Using an RValue gives Callback Ownership.
+//   - Ownership is transferred from Callback to callee on the first Run().
+//   - Callback supports unbound arguments.
+TEST_F(BindTest, ContainerOfMoveOnlyValues) {
+  int deletes = 0;
+
+  // Tests the Passed() function's support for pointers.
+  std::vector<scoped_ptr<DeleteCounter>> ptrs;
+  ptrs.emplace_back(new DeleteCounter(&deletes));
+  Callback<std::vector<scoped_ptr<DeleteCounter>>(void)> unused_callback =
+      Bind(&PassThru<std::vector<scoped_ptr<DeleteCounter>>>, std::move(ptrs));
+  EXPECT_EQ(0, deletes);
+
+  // If we never invoke the Callback, it retains ownership and deletes.
+  unused_callback.Reset();
+  EXPECT_EQ(1, deletes);
+
+  // Tests the Passed() function's support for rvalues.
+  deletes = 0;
+  ptrs.clear();
+  DeleteCounter* counter = new DeleteCounter(&deletes);
+  ptrs.emplace_back(counter);
+  Callback<std::vector<scoped_ptr<DeleteCounter>>(void)> callback =
+      Bind(&PassThru<std::vector<scoped_ptr<DeleteCounter>>>, std::move(ptrs));
+  EXPECT_EQ(0, deletes);
+
+  // Check that ownership can be transferred back out.
+  std::vector<scoped_ptr<DeleteCounter>> result = callback.Run();
+  ASSERT_EQ(1u, result.size());
+  ASSERT_EQ(counter, result[0].get());
+  EXPECT_EQ(0, deletes);
+
+  // Resetting does not delete since ownership was transferred.
+  callback.Reset();
+  EXPECT_EQ(0, deletes);
+
+  // Ensure that we actually did get ownership.
+  result.clear();
+  EXPECT_EQ(1, deletes);
+
+  // Test unbound argument forwarding.
+  Callback<std::vector<scoped_ptr<DeleteCounter>>(
+      std::vector<scoped_ptr<DeleteCounter>>)>
+      cb_unbound = Bind(&PassThru<std::vector<scoped_ptr<DeleteCounter>>>);
+  ptrs.clear();
+  ptrs.emplace_back(new DeleteCounter(&deletes));
+  cb_unbound.Run(std::move(ptrs));
+}
+
 // Argument Copy-constructor usage for non-reference parameters.
 //   - Bound arguments are only copied once.
 //   - Forwarded arguments are only copied once.
 //   - Forwarded arguments with coercions are only copied twice (once for the
 //     coercion, and one for the final dispatch).
 TEST_F(BindTest, ArgumentCopies) {
   int copies = 0;
   int assigns = 0;
 
   CopyCounter counter(&copies, &assigns);
@@ skipping 55 matching lines @@
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 }
 
 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
         //     GTEST_HAS_DEATH_TEST
 
 }  // namespace
 }  // namespace base