Allow CrossThreadPersistent in collections

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/Member.h"
 #include "platform/heap/PersistentNode.h"
 #include "wtf/Allocator.h"
@@ skipping 59 matching lines @@
         checkPointer();
     }
 
     template<typename U>
     PersistentBase(const Member<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
     }
 
+    PersistentBase(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1))
+    {
+        initialize();
+        checkPointer();
+    }
+
     ~PersistentBase()
     {
         uninitialize();
         m_raw = nullptr;
     }
 
+    bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
+
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
         if (weaknessConfiguration == WeakPersistentConfiguration) {
             visitor->registerWeakCell(&m_raw);
         } else {
             visitor->mark(m_raw);
         }
@@ skipping 81 matching lines @@
                 initialize();
             return;
         }
         uninitialize();
     }
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
         ASSERT(!m_persistentNode);
-        if (!m_raw)
+        if (!m_raw || isHashTableDeletedValue())
             return;
 
         TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>, &PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>::trace>::trampoline;
         if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             ProcessHeap::crossThreadPersistentRegion().allocatePersistentNode(m_persistentNode, this, traceCallback);
             return;
         }
         ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
         ASSERT(state->checkThread());
         m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(this, traceCallback);
@@ skipping 16 matching lines @@
         ASSERT(state->checkThread());
         // Persistent handle must be created and destructed in the same thread.
         ASSERT(m_state == state);
         state->freePersistentNode(m_persistentNode);
         m_persistentNode = nullptr;
     }
 
     void checkPointer()
     {
 #if ENABLE(ASSERT) && defined(ADDRESS_SANITIZER)
-        if (!m_raw)
+        if (!m_raw || isHashTableDeletedValue())
             return;
 
         // ThreadHeap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
         // object. In other words, it checks that the pointer is either of:
         //
         //   (a) a pointer to the head of an on-heap object.
         //   (b) a pointer to the head of an on-heap mixin object.
         //
         // Otherwise, ThreadHeap::isHeapObjectAlive will crash when it calls
         // header->checkHeader().
@@ skipping 21 matching lines @@
 public:
     Persistent() : Parent() { }
     Persistent(std::nullptr_t) : Parent(nullptr) { }
     Persistent(T* raw) : Parent(raw) { }
     Persistent(T& raw) : Parent(raw) { }
     Persistent(const Persistent& other) : Parent(other) { }
     template<typename U>
     Persistent(const Persistent<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const Member<U>& other) : Parent(other) { }
+    Persistent(WTF::HashTableDeletedValueType x) : Parent(x) { }
 
     template<typename U>
     Persistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     Persistent& operator=(std::nullptr_t)
     {
@@ skipping 89 matching lines @@
 public:
     CrossThreadPersistent() : Parent() { }
     CrossThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadPersistent(T* raw) : Parent(raw) { }
     CrossThreadPersistent(T& raw) : Parent(raw) { }
     CrossThreadPersistent(const CrossThreadPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const CrossThreadPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
+    CrossThreadPersistent(WTF::HashTableDeletedValueType x) : Parent(x) { }
 
     T* atomicGet() { return Parent::atomicGet(); }
 
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
 
@@ skipping 290 matching lines @@
 
 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(); }
 
 } // namespace blink
 
 namespace WTF {
 
+template <typename T>
+struct PersistentHash : MemberHash<T> {
+    STATIC_ONLY(PersistentHash);
+};
+
+template <typename T>
+struct CrossThreadPersistentHash : MemberHash<T> {
+    STATIC_ONLY(CrossThreadPersistentHash);
+};
+
+template <typename T>
+struct DefaultHash<blink::Persistent<T>> {
+    STATIC_ONLY(DefaultHash);
+    using Hash = PersistentHash<T>;
+};
+
+template <typename T>
+struct DefaultHash<blink::CrossThreadPersistent<T>> {
+    STATIC_ONLY(DefaultHash);
+    using Hash = CrossThreadPersistentHash<T>;
+};
+
 template<typename T>
 struct ParamStorageTraits<blink::WeakPersistentThisPointer<T>> {
     STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = blink::WeakPersistent<T>;
 
     static StorageType wrap(const blink::WeakPersistentThisPointer<T>& value) { return value.value(); }
 
     // WTF::FunctionWrapper<> handles WeakPtr<>, so recast this weak persistent
     // into it.
@@ skipping 15 matching lines @@
     // into it.
     //
     // TODO(sof): remove this hack once wtf/Functional.h can also work with a type like
     // CrossThreadWeakPersistent<>.
     static WeakPtr<T> unwrap(const StorageType& value) { return WeakPtr<T>(WeakReference<T>::create(value.get())); }
 };
 
 } // namespace WTF
 
 #endif // Persistent_h