Enable boolean testing of scoped_refptr<T>.

base/memory/ref_counted_unittest.cc

 // Copyright (c) 2012 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/ref_counted.h"
 
 #include "base/test/opaque_ref_counted.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class SelfAssign : public base::RefCounted<SelfAssign> {
+ protected:
+  virtual ~SelfAssign() {}
+
+ private:
   friend class base::RefCounted<SelfAssign>;
+};
 
-  ~SelfAssign() {}
+class Derived : public SelfAssign {
+ protected:
+  ~Derived() override {}
+
+ private:
+  friend class base::RefCounted<Derived>;
 };
 
 class CheckDerivedMemberAccess : public scoped_refptr<SelfAssign> {
  public:
   CheckDerivedMemberAccess() {
     // This shouldn't compile if we don't have access to the member variable.
     SelfAssign** pptr = &ptr_;
     EXPECT_EQ(*pptr, ptr_);
   }
 };
@@ skipping 39 matching lines @@
 
 TEST(RefCountedUnitTest, ScopedRefPtrToOpaque) {
   scoped_refptr<base::OpaqueRefCounted> p = base::MakeOpaqueRefCounted();
   base::TestOpaqueRefCounted(p);
 
   scoped_refptr<base::OpaqueRefCounted> q;
   q = p;
   base::TestOpaqueRefCounted(p);
   base::TestOpaqueRefCounted(q);
 }
+
+TEST(RefCountedUnitTest, BooleanTesting) {
+  scoped_refptr<SelfAssign> p;
+  EXPECT_FALSE(p);
+  p = new SelfAssign;
+  EXPECT_TRUE(p);
+}
+
+TEST(RefCountedUnitTest, Equality) {
+  scoped_refptr<SelfAssign> p1(new SelfAssign);
+  scoped_refptr<SelfAssign> p2(new SelfAssign);
+
+  EXPECT_EQ(p1, p1);
+  EXPECT_EQ(p2, p2);
+
+  EXPECT_NE(p1, p2);

[dcheng, 2014/11/25 08:44:36]

This is primarily to ensure that we're not inadvertently converting both sides
to a Testable before doing the comparison.

+  EXPECT_NE(p2, p1);
+}
+
+TEST(RefCountedUnitTest, ConvertibleEquality) {

[dcheng, 2014/11/25 08:44:36]

shared_ptr allows comparisons between convertible types
(http://en.cppreference.com/w/cpp/memory/shared_ptr/operator_cmp), so I opted to
test that behavior explicitly here.

+  scoped_refptr<Derived> p1(new Derived);
+  scoped_refptr<SelfAssign> p2;
+
+  EXPECT_NE(p1, p2);
+  EXPECT_NE(p2, p1);
+
+  p2 = p1;
+
+  EXPECT_EQ(p1, p2);
+  EXPECT_EQ(p2, p1);
+}