Member initialization for scoped_refptr<T>::ptr_.

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 7c4e07af49e4a1e48fba7019d38e4177278a4665..5a19266326f06bc38def78c64c235d6a87bba1df 100644
--- a/base/memory/ref_counted_unittest.cc
+++ b/base/memory/ref_counted_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "base/memory/ref_counted.h"
 
+#include <utility>
+
 #include "base/test/opaque_ref_counted.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -156,13 +158,50 @@ TEST(RefCountedUnitTest, ScopedRefPtrToSelfMoveAssignment) {
 }
 
 TEST(RefCountedUnitTest, ScopedRefPtrToOpaque) {
-  scoped_refptr<base::OpaqueRefCounted> p = base::MakeOpaqueRefCounted();
-  base::TestOpaqueRefCounted(p);
+  scoped_refptr<base::OpaqueRefCounted> initial = base::MakeOpaqueRefCounted();
+  base::TestOpaqueRefCounted(initial);
+
+  scoped_refptr<base::OpaqueRefCounted> assigned;
+  assigned = initial;
+  base::TestOpaqueRefCounted(initial);
+  base::TestOpaqueRefCounted(assigned);
+
+  scoped_refptr<base::OpaqueRefCounted> copied(initial);
+  base::TestOpaqueRefCounted(initial);
+  base::TestOpaqueRefCounted(copied);
+
+  scoped_refptr<base::OpaqueRefCounted> moved(std::move(initial));

[danakj, 2016/10/27 22:10:54]

Isn't this just testing different ways to make a scoped_refptr? Once you have
one, all called to TestOpaqueRefCounted are the same at that point?

[gab, 2016/10/28 14:02:26]

Right I guess the multiple calls to TestOpaqueRefCounted() aren't verifying much
(i.e. the test is mostly about making sure it compiles not about logic testing
so the multiple calls aren't necessarily helpful -- other than to verify the
move happened correctly but other tests are already testing move so this is
perhaps overkill, WDYT?)

[danakj, 2016/10/29 00:49:09]

Yes if u wanna test them do it as a separate test if its not redundant with
other tests, but no need to call TestOpaqueRefCounted after each one :)

[gab, 2016/10/31 15:01:14]

Removed extraneous calls.

+  EXPECT_EQ(nullptr, initial.get());
+  base::TestOpaqueRefCounted(moved);
+
+  scoped_refptr<base::OpaqueRefCounted> move_assigned;
+  move_assigned = std::move(moved);
+  EXPECT_EQ(nullptr, moved.get());
+  base::TestOpaqueRefCounted(move_assigned);
+}
+
+TEST(RefCountedUnitTest, ScopedRefPtrToOpaqueThreadSafe) {
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> initial =
+      base::MakeOpaqueRefCountedThreadSafe();
+  base::TestOpaqueRefCountedThreadSafe(initial);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> assigned;
+  assigned = initial;
+  base::TestOpaqueRefCountedThreadSafe(initial);
+  base::TestOpaqueRefCountedThreadSafe(assigned);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> copied(initial);
+  base::TestOpaqueRefCountedThreadSafe(initial);
+  base::TestOpaqueRefCountedThreadSafe(copied);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> moved(std::move(initial));
+  EXPECT_EQ(nullptr, initial.get());
+  base::TestOpaqueRefCountedThreadSafe(moved);
 
-  scoped_refptr<base::OpaqueRefCounted> q;
-  q = p;
-  base::TestOpaqueRefCounted(p);
-  base::TestOpaqueRefCounted(q);
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> move_assigned;
+  move_assigned = std::move(moved);
+  EXPECT_EQ(nullptr, moved.get());
+  base::TestOpaqueRefCountedThreadSafe(move_assigned);
 }
 
 TEST(RefCountedUnitTest, BooleanTesting) {