Add a PassScopedPtr into base/memory.

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/pass_scoped_ptr.h"
+#include "base/memory/ref_counted.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 124 matching lines @@
   ~DeleteCounter() {
     (*deletes_)++;
   }
 
   void VoidMethod0() {}
 
  private:
   int* deletes_;
 };
 
+DeleteCounter* MaybeCapture(PassScopedPtr<DeleteCounter> ptr,
+                            bool expect_valid,
+                            bool should_capture) {
+  EXPECT_EQ(expect_valid, ptr.is_valid());
+  if (should_capture) {
+    scoped_ptr<DeleteCounter> scoped;
+    ptr.ToScopedPtr(&scoped);
+    return scoped.release();
+  }
+  return NULL;
+}
+
 // 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 462 matching lines @@
   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);
 }
 
+// PassScopedPtr() wrapper support.
+//   - Binding PassScopedPtr gives Callback Ownership.
+//   - Callback only transfers ownership of PassScopedPtr on explicit Pass()
+//     or ToScopedPtr() call.
+TEST_F(BindTest, PassScopedPtr) {
+  int deletes = 0;
+
+  // If we never invoke the Callback, it returns ownership and deletes.
+  Callback<DeleteCounter*(bool, bool)> unused_callback =
+      Bind(&MaybeCapture,
+           PassScopedPtr<DeleteCounter>(new DeleteCounter(&deletes)).Pass());
+  EXPECT_EQ(0, deletes);

[levin, 2011/11/02 00:51:30]

Shouldn't these EXPECT calls be ASSERT?

If something goes wrong, you could be using invalid memory and causing the test
suite to crash.

[awong, 2011/11/11 00:21:58]

Good catch. Fixed.

+  unused_callback.Reset();
+  EXPECT_EQ(1, deletes);
+
+  // TODO(ajwong): Also test that Pass() captures the value, and that
+  // after the value is captured, is_valid() is false.
+
+  // Check that ownership is only transfered if ToScopedPtr() is called.
+  deletes = 0;
+  DeleteCounter* counter = new DeleteCounter(&deletes);
+  EXPECT_EQ(0, deletes);
+  Callback<DeleteCounter*(bool, bool)> callback =
+      Bind(&MaybeCapture,
+           PassScopedPtr<DeleteCounter>(counter).Pass());
+  EXPECT_EQ(0, deletes);
+
+  // Multiple calls do not capture.
+  //
+  // TODO(ajwong): Actually assert is_valid() inside the test.
+  EXPECT_TRUE(callback.Run(true, false) == NULL);
+  EXPECT_TRUE(callback.Run(true, false) == NULL);
+  EXPECT_EQ(0, deletes);
+
+  // Transfer ownership out.
+  scoped_ptr<DeleteCounter> result(callback.Run(true, true));
+  EXPECT_EQ(counter, result.get());
+  EXPECT_EQ(0, deletes);
+
+  // Next invocation will find the PassScopedPtr is invalid.
+  EXPECT_TRUE(callback.Run(false, false) == NULL);
+  EXPECT_EQ(0, deletes);
+
+  // Resetting does not delete since ownership was transfered.
+  callback.Reset();
+  EXPECT_EQ(0, deletes);

[levin, 2011/11/02 00:51:30]

Why not "delete counter" here to avoid leaks in tests which make valgrind
unhappy?

[awong, 2011/11/11 00:21:58]

Don't need to. result owns it.  There's no way to leak with only calls to
PassScopedPtr<> :)

+}
+
 // 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).
 TEST_F(BindTest, ArgumentCopies) {
   int copies = 0;
   int assigns = 0;
 
   CopyCounter counter(&copies, &assigns);
@@ skipping 43 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