Add move support for scoped_refptr.

base/memory/ref_counted_unittest.cc

Index: base/memory/ref_counted_unittest.cc
diff --git a/base/memory/ref_counted_unittest.cc b/base/memory/ref_counted_unittest.cc
index f75cd38f19c86d530237200e37792a2cde9480eb..aa98bda3c85fd888cbff1f122dd6ca1bd119651b 100644
--- a/base/memory/ref_counted_unittest.cc
+++ b/base/memory/ref_counted_unittest.cc
@@ -53,6 +53,30 @@ class ScopedRefPtrToSelf : public base::RefCounted<ScopedRefPtrToSelf> {
 
 bool ScopedRefPtrToSelf::was_destroyed_ = false;
 
+class ScopedRefPtrCount : public base::RefCounted<ScopedRefPtrCount> {
+ public:
+  ScopedRefPtrCount() { ++constructor_count_; }
+
+  static int constructor_count() { return constructor_count_; }
+
+  static int destructor_count() { return destructor_count_; }
+
+  static void reset_count() {
+    constructor_count_ = 0;
+    destructor_count_ = 0;
+  }
+
+ private:
+  friend class base::RefCounted<ScopedRefPtrCount>;
+  ~ScopedRefPtrCount() { ++destructor_count_; }
+
+  static int constructor_count_;
+  static int destructor_count_;
+};
+
+int ScopedRefPtrCount::constructor_count_ = 0;
+int ScopedRefPtrCount::destructor_count_ = 0;
+
 }  // end namespace
 
 TEST(RefCountedUnitTest, TestSelfAssignment) {
@@ -113,3 +137,204 @@ TEST(RefCountedUnitTest, ConvertibleEquality) {
   EXPECT_EQ(p1, p2);
   EXPECT_EQ(p2, p1);
 }
+
+TEST(RefCountedUnitTest, SelfMoveAssignment) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p(raw);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    p = p.Pass();
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+    EXPECT_EQ(raw, p.get());
+
+    // p goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveAssignment1) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p1(raw);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      scoped_refptr<ScopedRefPtrCount> p2;
+
+      p2 = p1.Pass();
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(nullptr, p1.get());
+      EXPECT_EQ(raw, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveAssignment2) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p1;
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      scoped_refptr<ScopedRefPtrCount> p2(raw);
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+      p1 = p2.Pass();
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(raw, p1.get());
+      EXPECT_EQ(nullptr, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveAssignmentSameInstance1) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p1(raw);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      scoped_refptr<ScopedRefPtrCount> p2(p1);
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+      p1 = p2.Pass();
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(raw, p1.get());
+      EXPECT_EQ(nullptr, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveAssignmentSameInstance2) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p1(raw);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      scoped_refptr<ScopedRefPtrCount> p2(p1);
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+      p2 = p1.Pass();
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(nullptr, p1.get());
+      EXPECT_EQ(raw, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveAssignmentDifferentInstances) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw1 = new ScopedRefPtrCount();
+    scoped_refptr<ScopedRefPtrCount> p1(raw1);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      ScopedRefPtrCount *raw2 = new ScopedRefPtrCount();
+      scoped_refptr<ScopedRefPtrCount> p2(raw2);
+      EXPECT_EQ(2, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+      p1 = p2.Pass();
+      EXPECT_EQ(2, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(raw2, p1.get());
+      EXPECT_EQ(nullptr, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(2, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(2, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(2, ScopedRefPtrCount::destructor_count());
+}
+
+TEST(RefCountedUnitTest, MoveConstructor) {
+  ScopedRefPtrCount::reset_count();
+
+  {
+    ScopedRefPtrCount *raw = new ScopedRefPtrCount();

[danakj, 2015/04/10 20:14:32]

Can you add some tests with conversion where T != U for the templated type?

[Kibeom Kim (inactive), 2015/04/12 07:35:14]

Done.

+    scoped_refptr<ScopedRefPtrCount> p1(raw);
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+
+    {
+      scoped_refptr<ScopedRefPtrCount> p2(p1.Pass());
+      EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+      EXPECT_EQ(0, ScopedRefPtrCount::destructor_count());
+      EXPECT_EQ(nullptr, p1.get());
+      EXPECT_EQ(raw, p2.get());
+
+      // p2 goes out of scope.
+    }
+    EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+    EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+
+    // p1 goes out of scope.
+  }
+  EXPECT_EQ(1, ScopedRefPtrCount::constructor_count());
+  EXPECT_EQ(1, ScopedRefPtrCount::destructor_count());
+}