Add a PassScopedPtr into base/memory.

base/memory/pass_scoped_ptr_unittest.cc

Index: base/memory/pass_scoped_ptr_unittest.cc
diff --git a/base/memory/pass_scoped_ptr_unittest.cc b/base/memory/pass_scoped_ptr_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5c0f2cba1132279428317222972175bc93fdddf3
--- /dev/null
+++ b/base/memory/pass_scoped_ptr_unittest.cc
@@ -0,0 +1,100 @@
+// 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/memory/pass_scoped_ptr.h"
+
+#include "base/basictypes.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+namespace {
+
+class ConDecLogger {
+ public:
+  ConDecLogger() : ptr_(NULL) { }
+  explicit ConDecLogger(int* ptr) { set_ptr(ptr); }
+  ~ConDecLogger() { --*ptr_; }
+
+ private:
+  void set_ptr(int* ptr) { ptr_ = ptr; ++*ptr_; }
+
+  int* ptr_;
+  DISALLOW_COPY_AND_ASSIGN(ConDecLogger);
+};
+
+}  // namespace
+
+TEST(PassScopedPtrTest, BasicMethods) {
+  int constructed = 0;
+
+  {
+    ConDecLogger* logger = new ConDecLogger(&constructed);
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr(logger);
+    EXPECT_EQ(1, constructed);
+    EXPECT_EQ(logger, pass_scoped_ptr.value_.raw_ptr);
+    EXPECT_TRUE(pass_scoped_ptr.is_valid());
+  }
+  EXPECT_EQ(0, constructed);
+
+  // Test ToScopedPtr();
+  {
+    ConDecLogger* logger = new ConDecLogger(&constructed);
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr(logger);
+    EXPECT_EQ(1, constructed);
+
+    scoped_ptr<ConDecLogger> scoped;
+    pass_scoped_ptr.ToScopedPtr(&scoped);
+    EXPECT_EQ(logger, scoped.get());
+    EXPECT_TRUE(pass_scoped_ptr.value_.raw_ptr == NULL);
+    EXPECT_FALSE(pass_scoped_ptr.is_valid());
+    EXPECT_EQ(1, constructed);
+  }
+  EXPECT_EQ(0, constructed);
+}
+
+TEST(PassScopedPtrTest, PassBehavior) {
+  int constructed = 0;
+  // Test Pass constructor;
+  {
+    ConDecLogger* logger = new ConDecLogger(&constructed);
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr(logger);
+    EXPECT_EQ(1, constructed);
+
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr2(pass_scoped_ptr.Pass());
+    EXPECT_EQ(1, constructed);
+    EXPECT_FALSE(pass_scoped_ptr.is_valid());
+    EXPECT_TRUE(pass_scoped_ptr2.is_valid());
+  }
+  EXPECT_EQ(0, constructed);
+}
+
+TEST(PassScopedPtrTest, AnchorBehavior) {
+  int constructed = 0;
+  // Test destruction semantics when anchored.
+  {
+    ConDecLogger* logger = new ConDecLogger(&constructed);
+    subtle::PassScopedPtrAnchor<ConDecLogger> anchor(
+        MakePassScopedPtr(logger));

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

If I call MakePassScopedPtr on a scoped_ptr, will it work?

Personally, I wish I could do that. Rather than MakePassScopedPtr(p.release()).
but I guess the other is ok for now and this could be added later if that
becomes a common pattern.

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

I like that you have explicitly tell the scoped_ptr to release().  The other
solution would require using a reference, which is disallowed by Google style.

+    EXPECT_EQ(1, constructed);
+    {
+      // Deletion of PassScopedPtr when anchored does nothing.
+      PassScopedPtr<ConDecLogger> pass_scoped_ptr(&anchor);
+      EXPECT_EQ(1, constructed);
+    }
+    EXPECT_EQ(1, constructed);
+
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr(&anchor);
+    pass_scoped_ptr.Pass();
+    EXPECT_EQ(0, constructed);
+    EXPECT_FALSE(pass_scoped_ptr.is_valid());
+
+    // A second PassScopedPtr for an anchor should be immediately invalid.
+    PassScopedPtr<ConDecLogger> pass_scoped_ptr2(&anchor);
+    EXPECT_FALSE(pass_scoped_ptr2.is_valid());
+  }
+  EXPECT_EQ(0, constructed);
+}
+

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

Why doesn't returntype need to be used/tested here? (Or should it never show up
in usage like this?)

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

...cause I forgot to do it? :P

Added unittest.

+}  // namespace base