WIP - allow scoped_refptr to be used without full defn of T

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 251 matching lines @@
 //
 //     b = a;
 //     // now, |a| and |b| each own a reference to the same MyFoo object.
 //   }
 //
 template <class T>
 class scoped_refptr {
  public:
   typedef T element_type;
 
+  // RefCounted<T> or RefCountedThreadSafe<T> depending on the type implemented
+  // by T (or T itself for RefCountedThreadSafe<T, CustomTraits> and the rare
+  // use case of classes providing their own AddRef/Release methods and being
+  // stored in a scoped_refptr).
+  using RefCountedType = typename std::conditional<
+      std::is_convertible<T*, base::RefCounted<T>*>::value,
+      base::RefCounted<T>,
+      typename std::conditional<
+          std::is_convertible<T*, base::RefCountedThreadSafe<T>*>::value,
+          base::RefCountedThreadSafe<T>,
+          T>::type>::type;
+
   scoped_refptr() = default;
 
   scoped_refptr(T* p) : ptr_(p) {
-    if (ptr_)
-      AddRef(ptr_);
+    if (ref_)
+      AddRef(ref_);
   }
 
   // Copy constructor.
   scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
-    if (ptr_)
-      AddRef(ptr_);
+    if (ref_)
+      AddRef(ref_);
   }
 
   // Copy conversion constructor.
   template <typename U,
             typename = typename std::enable_if<
                 std::is_convertible<U*, T*>::value>::type>
   scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
-    if (ptr_)
-      AddRef(ptr_);
+    if (ref_)
+      AddRef(ref_);
   }
 
   // Move constructor. This is required in addition to the conversion
   // constructor below in order for clang to warn about pessimizing moves.
   scoped_refptr(scoped_refptr&& r) : ptr_(r.get()) { r.ptr_ = nullptr; }
 
   // Move conversion constructor.
   template <typename U,
             typename = typename std::enable_if<
                 std::is_convertible<U*, T*>::value>::type>
   scoped_refptr(scoped_refptr<U>&& r) : ptr_(r.get()) {
     r.ptr_ = nullptr;
   }
 
   ~scoped_refptr() {
-    if (ptr_)
-      Release(ptr_);
+    if (ref_)
+      Release(ref_);
   }
 
   T* get() const { return ptr_; }
 
   T& operator*() const {
     assert(ptr_ != nullptr);
     return *ptr_;
   }
 
   T* operator->() const {
     assert(ptr_ != nullptr);
     return ptr_;
   }
 
   scoped_refptr<T>& operator=(T* p) {
     // AddRef first so that self assignment should work
+    // Note: This AddRef() can't use the |ref_| trick, so assigning from a naked
+    // pointer requires the assignor to have the full definition of |T|.
     if (p)
       AddRef(p);
-    T* old_ptr = ptr_;
+    const RefCountedType* old_ref = ref_;
     ptr_ = p;
-    if (old_ptr)
-      Release(old_ptr);
+    if (old_ref)
+      Release(old_ref);
     return *this;
   }
 
   scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
     return *this = r.ptr_;
   }
 
   template <typename U>
   scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
     return *this = r.get();
@@ skipping 31 matching lines @@
   bool operator!=(const scoped_refptr<U>& rhs) const {
     return !operator==(rhs);
   }
 
   template <typename U>
   bool operator<(const scoped_refptr<U>& rhs) const {
     return ptr_ < rhs.get();
   }
 
  protected:
+  //FIXME need to update |ref_| when updating |ptr_|.
   T* ptr_ = nullptr;
 
+  // |ref_| merely points to |ptr_| but the type checking is done when
+  // scoped_refptr is constructed instead of when it's used, this allows
+  // callsites that merely do:
+  //     void PassRefToFoo(Foo* foo, scoped_refptr<T> t) {
+  //       foo->TakeRef(std::move(t));
+  //     }
+  // to compile without the full definition of |T| as they can perform
+  // AddRef/Release operations on it without having to know that it implements
+  // RefCountedInterface.
+  //FIXME: This still doesn't work because template instantiations still need to
+  //know the full type to derive |RefCountedType|...
+  const RefCountedType* ref_ = ptr_;
+
  private:
   // 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);
+  static void AddRef(const RefCountedType* ref_type);
+  static void Release(const RefCountedType* ref_type);
 };
 
+// static
 template <typename T>
-void scoped_refptr<T>::AddRef(T* ptr) {
-  ptr->AddRef();
+void scoped_refptr<T>::AddRef(
+    const scoped_refptr<T>::RefCountedType* ref_type) {
+  ref_type->AddRef();
 }
 
+// static
 template <typename T>
-void scoped_refptr<T>::Release(T* ptr) {
-  ptr->Release();
+void scoped_refptr<T>::Release(
+    const scoped_refptr<T>::RefCountedType* ref_type) {
+  ref_type->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);
 }
 
 template <typename T, typename U>
@@ skipping 35 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_