Add Pass(), which implements move semantics, to scoped_ptr, scoped_array, and scoped_ptr_malloc.

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"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace base {
 namespace {
 
@@ skipping 77 matching lines @@
   CopyCounter(int* copies, int* assigns)
       : copies_(copies), assigns_(assigns) {
   }
 
   CopyCounter(const CopyCounter& other)
       : copies_(other.copies_),
         assigns_(other.assigns_) {
     (*copies_)++;
   }
 
-  // Probing for copies from coerscion.
+  // Probing for copies from coercion.
   CopyCounter(const DerivedCopyCounter& other)
       : copies_(other.copies_),
         assigns_(other.assigns_) {
     (*copies_)++;
   }
 
   const CopyCounter& operator=(const CopyCounter& rhs) {
     copies_ = rhs.copies_;
     assigns_ = rhs.assigns_;
 
@@ skipping 26 matching lines @@
   ~DeleteCounter() {
     (*deletes_)++;
   }
 
   void VoidMethod0() {}
 
  private:
   int* deletes_;
 };
 
+template <typename T>
+T PassThru(T scoper) {
+  return scoper.Pass();
+}
+
 // 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 472 matching lines @@
 
 // Test Owned() support.
 TEST_F(BindTest, Owned) {
   int deletes = 0;
   DeleteCounter* counter = new DeleteCounter(&deletes);
 
   // If we don't capture, delete happens on Callback destruction/reset.
   // return the same value.
   Callback<DeleteCounter*(void)> no_capture_cb =
       Bind(&PolymorphicIdentity<DeleteCounter*>, Owned(counter));
-  EXPECT_EQ(counter, no_capture_cb.Run());
-  EXPECT_EQ(counter, no_capture_cb.Run());
+  ASSERT_EQ(counter, no_capture_cb.Run());
+  ASSERT_EQ(counter, no_capture_cb.Run());
   EXPECT_EQ(0, deletes);
   no_capture_cb.Reset();  // This should trigger a delete.
   EXPECT_EQ(1, deletes);
 
   deletes = 0;
   counter = new DeleteCounter(&deletes);
   base::Closure own_object_cb =
       Bind(&DeleteCounter::VoidMethod0, Owned(counter));
   own_object_cb.Run();
   EXPECT_EQ(0, deletes);
   own_object_cb.Reset();
   EXPECT_EQ(1, deletes);
 }
 
+// Passed() wrapper support.
+//   - Passed() can be constructed from a pointer to scoper.
+//   - 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));
+  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> >,
+           Passed(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(ptr.Pass());
+}
+
 // Argument Copy-constructor usage for non-reference parameters.
 //   - Bound arguments are only copied once.
 //   - Forwarded arguments are only copied once.
-//   - Forwarded arguments with coerscions are only copied twice (once for the
-//     coerscion, and one for the final dispatch).
+//   - 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);
 
   Callback<void(void)> copy_cb =
       Bind(&VoidPolymorphic1<CopyCounter>, counter);
   EXPECT_GE(1, copies);
   EXPECT_EQ(0, assigns);
@@ skipping 38 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