Start BindStateBase ref count from 1 instead of 0

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 <utility>
 
+#include "base/test/gtest_util.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:
@@ skipping 96 matching lines @@
 };
 
 scoped_refptr<Other> Overloaded(scoped_refptr<Other> other) {
   return other;
 }
 
 scoped_refptr<SelfAssign> Overloaded(scoped_refptr<SelfAssign> self_assign) {
   return self_assign;
 }
 
+class InitialRefCountIsOne : public base::RefCounted<InitialRefCountIsOne> {
+ public:
+  static constexpr base::subtle::StartRefCountFromOneTag kRefCountPreference =
+      base::subtle::kStartRefCountFromOneTag;

[tzik, 2017/03/30 13:16:28]

We should probably replace this with a macro.

[dcheng, 2017/03/30 21:15:25]

Sounds good to me.

(To give some background context: I think my original thought was we could use
the absence of the tag to use the original start-from-zero behavior. In theory,
this would let us incrementally migrate the codebase to using adoption
semantics. But this way should be fine too: if a subclass declares a preference,
it should still work.)

+
+  InitialRefCountIsOne() {}
+
+ private:
+  friend class base::RefCounted<InitialRefCountIsOne>;
+  ~InitialRefCountIsOne() {}
+};
 
 }  // end namespace
 
 TEST(RefCountedUnitTest, TestSelfAssignment) {
   SelfAssign* p = new SelfAssign;
   scoped_refptr<SelfAssign> var(p);
   var = var;
   EXPECT_EQ(var.get(), p);
 }
 
@@ skipping 386 matching lines @@
 
 TEST(RefCountedUnitTest, TestOverloadResolutionMove) {
   scoped_refptr<Derived> derived(new Derived);
   scoped_refptr<SelfAssign> expected(derived);
   EXPECT_EQ(expected, Overloaded(std::move(derived)));
 
   scoped_refptr<Other> other(new Other);
   scoped_refptr<Other> other2(other);
   EXPECT_EQ(other2, Overloaded(std::move(other)));
 }
+
+TEST(RefCountedUnitTest, TestInitialRefCountIsOne) {
+  scoped_refptr<InitialRefCountIsOne> obj =
+      base::MakeShared<InitialRefCountIsOne>();
+  obj = nullptr;
+
+  scoped_refptr<InitialRefCountIsOne> obj2 =
+      base::AdoptRef(new InitialRefCountIsOne);
+  obj2 = nullptr;
+}
+
+TEST(RefCountedDeathTest, TestAdoptRef) {
+  EXPECT_DCHECK_DEATH(make_scoped_refptr(new InitialRefCountIsOne));
+
+  InitialRefCountIsOne* ptr = nullptr;
+  EXPECT_DCHECK_DEATH(base::AdoptRef(ptr));
+
+  scoped_refptr<InitialRefCountIsOne> obj =
+      base::MakeShared<InitialRefCountIsOne>();
+  EXPECT_DCHECK_DEATH(base::AdoptRef(obj.get()));
+}