Introduce an injection point to configure the internal pointer of WeakPtr

base/memory/weak_ptr.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.
 
 // Weak pointers are pointers to an object that do not affect its lifetime,
 // and which may be invalidated (i.e. reset to nullptr) by the object, or its
 // owner, at any time, most commonly when the object is about to be deleted.
 
 // Weak pointers are useful when an object needs to be accessed safely by one
 // or more objects other than its owner, and those callers can cope with the
@@ skipping 63 matching lines @@
 #include <type_traits>
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequence_checker.h"
 
 namespace base {
 
-template <typename T> class SupportsWeakPtr;
-template <typename T> class WeakPtr;
+struct DefaultWeakPtrTraits {
+  template <typename T>
+  struct PointerHolder {
+   protected:
+    PointerHolder(T* ptr) : ptr_(ptr) {}
+    void reset() { ptr_ = nullptr; }
+    T* get() const { return ptr_; }
+
+   private:
+    T* ptr_;
+  };
+
+  template <typename T>
+  using PointerType = T*;
+};
+
+template <typename T, typename Traits = DefaultWeakPtrTraits>
+class SupportsWeakPtr;
+
+template <typename T, typename Pointer = DefaultWeakPtrTraits>
+class WeakPtr;
+
+template <typename T, typename Pointer = DefaultWeakPtrTraits>
+class WeakPtrFactory;
 
 namespace internal {
 // These classes are part of the WeakPtr implementation.
 // DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
 
 class BASE_EXPORT WeakReference {
  public:
   // Although Flag is bound to a specific SequencedTaskRunner, it may be
   // deleted from another via base::WeakPtr::~WeakPtr().
   class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> {
@@ skipping 61 matching lines @@
  protected:
   explicit WeakPtrBase(const WeakReference& ref);
 
   WeakReference ref_;
 };
 
 // This class provides a common implementation of common functions that would
 // otherwise get instantiated separately for each distinct instantiation of
 // SupportsWeakPtr<>.
 class SupportsWeakPtrBase {
+ private:
+  // This template function uses type inference to find a Base of Derived
+  // which is an instance of SupportsWeakPtr<Base>. We can then safely
+  // static_cast the Base* to a Derived*.
+  template <typename Derived, typename Base, typename Traits>
+  static WeakPtr<Derived, Traits> AsWeakPtrImpl(
+      Derived* t,
+      const SupportsWeakPtr<Base, Traits>&) {
+    WeakPtr<Base, Traits> ptr = t->Base::AsWeakPtr();
+    return WeakPtr<Derived, Traits>(ptr.ref_, static_cast<Derived*>(ptr.get()));
+  }
+
  public:
   // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This
   // conversion will only compile if there is exists a Base which inherits
   // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
   // function that makes calling this easier.
-  template<typename Derived>
-  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
+  template <typename Derived>
+  static auto StaticAsWeakPtr(Derived* t)
+      -> decltype(AsWeakPtrImpl<Derived>(t, *t)) {
     static_assert(
         std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
         "AsWeakPtr argument must inherit from SupportsWeakPtr");
     return AsWeakPtrImpl<Derived>(t, *t);
   }
-
- private:
-  // This template function uses type inference to find a Base of Derived
-  // which is an instance of SupportsWeakPtr<Base>. We can then safely
-  // static_cast the Base* to a Derived*.
-  template <typename Derived, typename Base>
-  static WeakPtr<Derived> AsWeakPtrImpl(
-      Derived* t, const SupportsWeakPtr<Base>&) {
-    WeakPtr<Base> ptr = t->Base::AsWeakPtr();
-    return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
-  }
 };
 
 }  // namespace internal
 
-template <typename T> class WeakPtrFactory;
-
 // The WeakPtr class holds a weak reference to |T*|.
 //
 // This class is designed to be used like a normal pointer.  You should always
 // null-test an object of this class before using it or invoking a method that
 // may result in the underlying object being destroyed.
 //
 // EXAMPLE:
 //
 //   class Foo { ... };
 //   WeakPtr<Foo> foo;
 //   if (foo)
 //     foo->method();
 //
-template <typename T>
-class WeakPtr : public internal::WeakPtrBase {
+template <typename T, typename Traits>
+class WeakPtr : public internal::WeakPtrBase,
+                public Traits::template PointerHolder<T> {
+ private:
+  using PointerHolder = typename Traits::template PointerHolder<T>;
+
  public:
-  WeakPtr() : ptr_(nullptr) {}
-
-  WeakPtr(std::nullptr_t) : ptr_(nullptr) {}
+  WeakPtr() : PointerHolder(nullptr) {}
+  WeakPtr(std::nullptr_t) : PointerHolder(nullptr) {}
 
   // Allow conversion from U to T provided U "is a" T. Note that this
   // is separate from the (implicit) copy and move constructors.
-  template <typename U>
-  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {
+  template <typename U, typename OtherTraits>
+  WeakPtr(const WeakPtr<U, OtherTraits>& other)
+      : WeakPtrBase(other), PointerHolder(other.get()) {}
+  template <typename U, typename OtherTraits>
+  WeakPtr(WeakPtr<U, OtherTraits>&& other)
+      : WeakPtrBase(std::move(other)), PointerHolder(other.get()) {}
+
+  T* get() const {
+    if (ref_.is_valid())
+      return PointerHolder::get();
+    return nullptr;
   }
-  template <typename U>
-  WeakPtr(WeakPtr<U>&& other)
-      : WeakPtrBase(std::move(other)), ptr_(other.ptr_) {}
-
-  T* get() const { return ref_.is_valid() ? ptr_ : nullptr; }
 
   T& operator*() const {
     DCHECK(get() != nullptr);
     return *get();
   }
   T* operator->() const {
     DCHECK(get() != nullptr);
     return get();
   }
 
   void reset() {
     ref_ = internal::WeakReference();
-    ptr_ = nullptr;
+    PointerHolder::reset();
   }
 
   // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
   explicit operator bool() const { return get() != nullptr; }
 
  private:
   friend class internal::SupportsWeakPtrBase;
-  template <typename U> friend class WeakPtr;
-  friend class SupportsWeakPtr<T>;
-  friend class WeakPtrFactory<T>;
-
-  WeakPtr(const internal::WeakReference& ref, T* ptr)
-      : WeakPtrBase(ref),
-        ptr_(ptr) {
-  }
+  template <typename, typename>
+  friend class WeakPtr;
+  friend class SupportsWeakPtr<T, Traits>;
+  friend class WeakPtrFactory<T, Traits>;
 
   // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
   // value is undefined (as opposed to nullptr).
-  T* ptr_;
+  WeakPtr(const internal::WeakReference& ref, T* ptr)
+      : WeakPtrBase(ref), PointerHolder(std::move(ptr)) {}
 };
 
 // Allow callers to compare WeakPtrs against nullptr to test validity.
-template <class T>
-bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+template <typename T, typename Traits>
+bool operator!=(const WeakPtr<T, Traits>& weak_ptr, std::nullptr_t) {
   return !(weak_ptr == nullptr);
 }
-template <class T>
-bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+template <typename T, typename Traits>
+bool operator!=(std::nullptr_t, const WeakPtr<T, Traits>& weak_ptr) {
   return weak_ptr != nullptr;
 }
-template <class T>
-bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+template <typename T, typename Traits>
+bool operator==(const WeakPtr<T, Traits>& weak_ptr, std::nullptr_t) {
   return weak_ptr.get() == nullptr;
 }
-template <class T>
-bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+template <typename T, typename Traits>
+bool operator==(std::nullptr_t, const WeakPtr<T, Traits>& weak_ptr) {
   return weak_ptr == nullptr;
 }
 
 // A class may be composed of a WeakPtrFactory and thereby
 // control how it exposes weak pointers to itself.  This is helpful if you only
 // need weak pointers within the implementation of a class.  This class is also
 // useful when working with primitive types.  For example, you could have a
 // WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
-template <class T>
-class WeakPtrFactory {
+template <typename T, typename Traits>
+class WeakPtrFactory : public Traits::template PointerHolder<T> {
+ private:
+  using PointerHolder = typename Traits::template PointerHolder<T>;
+
  public:
-  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {
-  }
+  explicit WeakPtrFactory(T* ptr) : PointerHolder(ptr) {}
 
-  ~WeakPtrFactory() { ptr_ = nullptr; }
+  ~WeakPtrFactory() { PointerHolder::reset(); }
 
-  WeakPtr<T> GetWeakPtr() {
-    DCHECK(ptr_);
-    return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);
+  WeakPtr<T, Traits> GetWeakPtr() {
+    DCHECK(PointerHolder::get());
+    return WeakPtr<T, Traits>(weak_reference_owner_.GetRef(),
+                              PointerHolder::get());
   }
 
   // Call this method to invalidate all existing weak pointers.
   void InvalidateWeakPtrs() {
-    DCHECK(ptr_);
+    DCHECK(PointerHolder::get());
     weak_reference_owner_.Invalidate();
   }
 
   // Call this method to determine if any weak pointers exist.
   bool HasWeakPtrs() const {
-    DCHECK(ptr_);
+    DCHECK(PointerHolder::get());
     return weak_reference_owner_.HasRefs();
   }
 
  private:
   internal::WeakReferenceOwner weak_reference_owner_;
-  T* ptr_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
 };
 
 // A class may extend from SupportsWeakPtr to let others take weak pointers to
 // it. This avoids the class itself implementing boilerplate to dispense weak
 // pointers.  However, since SupportsWeakPtr's destructor won't invalidate
 // weak pointers to the class until after the derived class' members have been
 // destroyed, its use can lead to subtle use-after-destroy issues.
-template <class T>
+template <typename T, typename Traits>
 class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
  public:
   SupportsWeakPtr() {}
 
-  WeakPtr<T> AsWeakPtr() {
-    return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
+  WeakPtr<T, Traits> AsWeakPtr() {
+    return WeakPtr<T, Traits>(weak_reference_owner_.GetRef(),
+                              static_cast<T*>(this));
   }
 
  protected:
   ~SupportsWeakPtr() {}
 
  private:
   internal::WeakReferenceOwner weak_reference_owner_;
   DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
 };
 
 // Helper function that uses type deduction to safely return a WeakPtr<Derived>
 // when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
 // extends a Base that extends SupportsWeakPtr<Base>.
 //
 // EXAMPLE:
 //   class Base : public base::SupportsWeakPtr<Producer> {};
 //   class Derived : public Base {};
 //
 //   Derived derived;
 //   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
 //
 // Note that the following doesn't work (invalid type conversion) since
 // Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
 // and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
 // the caller.
 //
 //   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
 
 template <typename Derived>
-WeakPtr<Derived> AsWeakPtr(Derived* t) {
+auto AsWeakPtr(Derived* t)
+    -> decltype(internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t)) {
   return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
 }
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_WEAK_PTR_H_