Introduce an injection point to configure the internal pointer of WeakPtr

third_party/WebKit/Source/platform/heap/Persistent.h

 // Copyright 2016 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 Persistent_h
 #define Persistent_h
 
 #include "platform/heap/Heap.h"
+#include "platform/heap/InlinedGlobalMarkingVisitor.h"
 #include "platform/heap/Member.h"
 #include "platform/heap/PersistentNode.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Atomics.h"
+#include "wtf/WeakPtr.h"
 
 namespace blink {
 
 // Marker used to annotate persistent objects and collections with,
 // so as to enable reliable testing for persistent references via
 // a type trait (see TypeTraits.h's IsPersistentReferenceType<>.)
 #define IS_PERSISTENT_REFERENCE_TYPE()               \
     public:                                          \
         using IsPersistentReferenceTypeMarker = int; \
     private:
@@ skipping 697 matching lines @@
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 
+struct RevocableWeakPersistentTraits {
+    template <typename T>
+    struct PointerHolder {
+    protected:
+        PointerHolder(T* ptr)
+            : m_ptr(ptr)
+        {
+        }
+        void reset() { m_ptr = nullptr; }
+        T* get() const { return m_ptr.get(); }
+    private:
+        WeakPersistent<T> m_ptr;
+    };
+};
+struct RevocableCrossThreadWeakPersistentTraits {
+    template <typename T>
+    struct PointerHolder {
+    protected:
+        PointerHolder(T* ptr)
+            : m_ptr(ptr)
+        {
+        }
+        void reset() { m_ptr = nullptr; }
+        T* get() const { return m_ptr.get(); }
+    private:
+        CrossThreadWeakPersistent<T> m_ptr;
+    };
+};
+struct RevocableWeakMemberTraits {
+    template <typename T>
+    struct PointerHolder {
+        DISALLOW_NEW();
+
+    protected:
+        PointerHolder(T* ptr)
+            : m_ptr(ptr)
+        {
+        }
+        void reset() { m_ptr = nullptr; }
+        T* get() const { return m_ptr.get(); }
+    public:
+        DEFINE_INLINE_TRACE()
+        {
+            visitor->trace(m_ptr);
+        }
+
+    private:
+        WeakMember<T> m_ptr;
+    };
+};
+
+template <typename T>
+using RevocableWeakPersistent = WTF::WeakPtr<T, RevocableWeakPersistentTraits>;
+template <typename T>
+using RevocableCrossThreadWeakPersistent = WTF::WeakPtr<T, RevocableCrossThreadWeakPersistentTraits>;
+template <typename T>
+using RevocableWeakMember = WTF::WeakPtr<T, RevocableWeakMemberTraits>;
+
+template <typename T>
+using RevocableWeakPersistentFactory = WTF::WeakPtrFactory<T, RevocableWeakPersistentTraits>;
+template <typename T>
+using RevocableCrossThreadWeakPersistentFactory = WTF::WeakPtrFactory<T, RevocableCrossThreadWeakPersistentTraits>;
+template <typename T>
+using RevocableWeakMemberFactory = WTF::WeakPtrFactory<T, RevocableWeakMemberTraits>;
+
 } // namespace blink
 
 namespace WTF {
 
 template <typename T>
 struct DefaultHash<blink::Persistent<T>> {
     STATIC_ONLY(DefaultHash);
     using Hash = MemberHash<T>;
 };
 
@@ skipping 27 matching lines @@
 
 template <typename T>
 struct BindUnwrapTraits<blink::CrossThreadWeakPersistent<T>> {
     static blink::CrossThreadPersistent<T> Unwrap(const blink::CrossThreadWeakPersistent<T>& wrapped)
     {
         blink::CrossThreadPersistentRegion::LockScope persistentLock(blink::ProcessHeap::crossThreadPersistentRegion());
         return blink::CrossThreadPersistent<T>(wrapped.get());
     }
 };
 
-}
+} // namespace base
 
 #endif // Persistent_h