Start BindStateBase ref count from 1 instead of 0

base/memory/ref_counted.h

 // 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.
 
 #ifndef BASE_MEMORY_REF_COUNTED_H_
 #define BASE_MEMORY_REF_COUNTED_H_
 
 #include <stddef.h>
 
 #include <cassert>
@@ skipping 367 matching lines @@
 
   template <typename U>
   bool operator<(const scoped_refptr<U>& rhs) const {
     return ptr_ < rhs.get();
   }
 
  protected:
   T* ptr_ = nullptr;
 
  private:
+  template <typename U>
+  friend scoped_refptr<U> AdoptRef(U*);
+
+  struct AdoptRefTag {};

[dcheng, 2017/03/06 22:09:18]

FWIW, the usual trick I've seen in the past is to use an enum here: for example,
see
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/webor...

[tzik, 2017/03/07 13:39:42]

Done.

+  scoped_refptr(T* p, AdoptRefTag) : ptr_(p) {}
+
   // Friend required for move constructors that set r.ptr_ to null.
   template <typename U>
   friend class scoped_refptr;
 
   // Non-inline helpers to allow:
   //     class Opaque;
   //     extern template class scoped_refptr<Opaque>;
   // Otherwise the compiler will complain that Opaque is an incomplete type.
   static void AddRef(T* ptr);
   static void Release(T* ptr);
@@ skipping 11 matching lines @@
   ptr->Release();
 }
 
 // Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
 // having to retype all the template arguments
 template <typename T>
 scoped_refptr<T> make_scoped_refptr(T* t) {
   return scoped_refptr<T>(t);
 }
 
+// Creates a scoped_refptr from a raw pointer without incrementing the reference
+// count. Use this only for a newly created object whose reference count starts
+// from 1 instead of 0.
+template <typename T>
+scoped_refptr<T> AdoptRef(T* t) {
+  DCHECK(!t || t->HasOneRef());
+  using Tag = typename scoped_refptr<T>::AdoptRefTag;
+  return scoped_refptr<T>(t, Tag());
+}
+
 template <typename T, typename U>
 bool operator==(const scoped_refptr<T>& lhs, const U* rhs) {
   return lhs.get() == rhs;
 }
 
 template <typename T, typename U>
 bool operator==(const T* lhs, const scoped_refptr<U>& rhs) {
   return lhs == rhs.get();
 }
 
@@ skipping 26 matching lines @@
 bool operator!=(std::nullptr_t null, const scoped_refptr<T>& rhs) {
   return !operator==(null, rhs);
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const scoped_refptr<T>& p) {
   return out << p.get();
 }
 
 #endif  // BASE_MEMORY_REF_COUNTED_H_