Make base::WeakPtr::Get() fast

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 78 matching lines @@
 // 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> {
    public:
     Flag();
 
-    void Invalidate();
-    bool IsValid() const;
+    // Get a pointer to the "Null Flag", a sentinel object used by WeakReference
+    // objects that don't point to a valid Flag, either because they're default
+    // consturcted or because they have been invalidated. This can be used like

[Nico, 2017/06/28 20:57:03]

typo consturcted

[hans, 2017/06/28 21:16:59]

Done.

+    // any other Flag object, but it is invalidated already from the start, and
+    // its refcount will never reach zero.
+    static Flag* NullFlag();
+
+    void Invalidate() {
+#if DCHECK_IS_ON()
+      if (this == NullFlag()) {
+        // The Null Flag does not participate in the sequence checks below.
+        // Since its state never changes, it can be accessed from any thread.
+        DCHECK(!is_valid_);
+        return;
+      }
+      // The flag being invalidated with a single ref implies that there are no
+      // weak pointers in existence. Allow deletion on other thread in this
+      // case.
+      DCHECK(sequence_checker_.CalledOnValidSequence() || HasOneRef())
+          << "WeakPtrs must be invalidated on the same sequenced thread.";
+#endif
+      is_valid_ = 0;
+    }
+
+    // Returns a pointer-sized bitmask of all 1s if valid or all 0s otherwise.
+    uintptr_t IsValid() const {
+#if DCHECK_IS_ON()
+      if (this == NullFlag()) {
+        // The Null Flag does not participate in the sequence checks below.
+        // Since its state never changes, it can be accessed from any thread.
+        DCHECK(!is_valid_);
+        return 0;
+      }
+      DCHECK(sequence_checker_.CalledOnValidSequence())
+          << "WeakPtrs must be checked on the same sequenced thread.";
+#endif
+      return is_valid_;
+    }
 
    private:
     friend class base::RefCountedThreadSafe<Flag>;
 
+    enum NullFlagTag { kNullFlagTag };
+    Flag(NullFlagTag);
+
     ~Flag();
 
+    uintptr_t is_valid_;
+#if DCHECK_IS_ON()
+    // Even if SequenceChecker is an empty class in non-dcheck builds, it still
+    // takes up space in the class.
     SequenceChecker sequence_checker_;
-    bool is_valid_;
+#endif
   };
 
   WeakReference();
   explicit WeakReference(const Flag* flag);
   ~WeakReference();
 
   WeakReference(WeakReference&& other);
   WeakReference(const WeakReference& other);
   WeakReference& operator=(WeakReference&& other) = default;
   WeakReference& operator=(const WeakReference& other) = default;
 
-  bool is_valid() const;
+  uintptr_t is_valid() const { return flag_->IsValid(); }
 
  private:
+  // Note: To avoid null-checks, flag_ always points to either Flag::NullFlag()
+  // or some other object.
   scoped_refptr<const Flag> flag_;
 };
 
 class BASE_EXPORT WeakReferenceOwner {
  public:
   WeakReferenceOwner();
   ~WeakReferenceOwner();
 
   WeakReference GetRef() const;
 
   bool HasRefs() const {
-    return flag_.get() && !flag_->HasOneRef();
+    return flag_ != WeakReference::Flag::NullFlag() && !flag_->HasOneRef();
   }
 
   void Invalidate();
 
  private:
   mutable scoped_refptr<WeakReference::Flag> flag_;
 };
 
 // This class simplifies the implementation of WeakPtr's type conversion
 // constructor by avoiding the need for a public accessor for ref_.  A
@@ skipping 70 matching lines @@
 
   // 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>
   WeakPtr(WeakPtr<U>&& other)
       : WeakPtrBase(std::move(other)), ptr_(other.ptr_) {}
 
-  T* get() const { return ref_.is_valid() ? ptr_ : nullptr; }
+  T* get() const {
+    // Intentionally bitwise and; see command on Flag::IsValid(). This provides
+    // a fast way of conditionally retrieving the pointer, and conveniently sets
+    // EFLAGS for any null-check performed by the caller.
+    return reinterpret_cast<T*>(ref_.is_valid() &
+                                reinterpret_cast<uintptr_t>(ptr_));
+  }
 
   T& operator*() const {
     DCHECK(get() != nullptr);
     return *get();
   }
   T* operator->() const {
     DCHECK(get() != nullptr);
     return get();
   }
 
@@ skipping 116 matching lines @@
 //   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
 
 template <typename Derived>
 WeakPtr<Derived> AsWeakPtr(Derived* t) {
   return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
 }
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_WEAK_PTR_H_