[Oilpan] Create UnsafePtr to store on-heap pointers in Vector

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

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 30 matching lines @@
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
 #include "wtf/MainThread.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
+template<typename T> class Member;
+template<typename T> class UntracedMember;
+
 enum WeaknessPersistentConfiguration {
     NonWeakPersistentConfiguration,
     WeakPersistentConfiguration
 };
 
 enum CrossThreadnessPersistentConfiguration {
     SingleThreadPersistentConfiguration,
     CrossThreadPersistentConfiguration
 };
 
@@ skipping 33 matching lines @@
 
     template<typename U>
     PersistentBase(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
+    PersistentBase(const UntracedMember<U>& other) : m_raw(other)
+    {
+        initialize();
+        checkPointer();
+        recordBacktrace();
+    }
+
+    template<typename U>
     PersistentBase(const Member<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
     PersistentBase(const RawPtr<U>& other) : m_raw(other.get())
     {
@@ skipping 55 matching lines @@
     }
 
     template<typename U>
     PersistentBase& operator=(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other)
     {
         assign(other);
         return *this;
     }
 
     template<typename U>
+    PersistentBase& operator=(const UntracedMember<U>& other)
+    {
+        assign(other);
+        return *this;
+    }
+
+    template<typename U>
     PersistentBase& operator=(const Member<U>& other)
     {
         assign(other);
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const RawPtr<U>& other)
     {
         assign(other);
@@ skipping 102 matching lines @@
     typedef PersistentBase<T, NonWeakPersistentConfiguration, SingleThreadPersistentConfiguration> Parent;
 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 UntracedMember<U>& other) : Parent(other) { }
+    template<typename U>
     Persistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const RawPtr<U>& other) : Parent(other.get()) { }
 
     template<typename U>
     Persistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
@@ skipping 11 matching lines @@
     }
 
     template<typename U>
     Persistent& operator=(const Persistent<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
+    Persistent& operator=(const UntracedMember<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
     Persistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const RawPtr<U>& other)
     {
         Parent::operator=(other);
@@ skipping 76 matching lines @@
     typedef PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 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 UntracedMember<U>& other) : Parent(other) { }
+    template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
 
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
@@ skipping 11 matching lines @@
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const CrossThreadPersistent<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
+    CrossThreadPersistent& operator=(const UntracedMember<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
     CrossThreadPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const RawPtr<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
 // Combines the behavior of CrossThreadPersistent and WeakPersistent.
 template<typename T>
 class CrossThreadWeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadWeakPersistent() : Parent() { }
     CrossThreadWeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadWeakPersistent(T* raw) : Parent(raw) { }
     CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
     CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadWeakPersistent(const CrossThreadWeakPersistent<U>& other) : Parent(other) { }
     template<typename U>
+    CrossThreadWeakPersistent(const UntracedMember<U>& other) : Parent(other) { }
+    template<typename U>
     CrossThreadWeakPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadWeakPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
@@ skipping 11 matching lines @@
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
+    CrossThreadWeakPersistent& operator=(const UntracedMember<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
     CrossThreadWeakPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const RawPtr<U>& other)
     {
         Parent::operator=(other);
@@ skipping 157 matching lines @@
     }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other)
     {
         checkPointer();
     }
 
+    template<typename U>
+    Member(const UntracedMember<U>& other) : m_raw(other)
+    {
+        checkPointer();
+    }
+
     Member(const Member& other) : m_raw(other)
     {
         checkPointer();
     }
 
     template<typename U>
     Member(const Member<U>& other) : m_raw(other)
     {
         checkPointer();
     }
@@ skipping 24 matching lines @@
 
     template<typename U>
     Member& operator=(const Member<U>& other)
     {
         m_raw = other;
         checkPointer();
         return *this;
     }
 
     template<typename U>
+    Member& operator=(const UntracedMember<U>& other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    template<typename U>
     Member& operator=(U* other)
     {
         m_raw = other;
         checkPointer();
         return *this;
     }
 
     template<typename U>
     Member& operator=(RawPtr<U> other)
     {
@@ skipping 68 matching lines @@
     WeakMember(std::nullptr_t) : Member<T>(nullptr) { }
 
     WeakMember(T* raw) : Member<T>(raw) { }
 
     WeakMember(WTF::HashTableDeletedValueType x) : Member<T>(x) { }
 
     template<typename U>
     WeakMember(const Persistent<U>& other) : Member<T>(other) { }
 
     template<typename U>
+    WeakMember(const UntracedMember<U>& other) : Member<T>(other) { }
+
+    template<typename U>
     WeakMember(const Member<U>& other) : Member<T>(other) { }
 
     template<typename U>
     WeakMember& operator=(const Persistent<U>& other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
     template<typename U>
     WeakMember& operator=(const Member<U>& other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
     template<typename U>
+    WeakMember& operator=(const UntracedMember<U>& other)
+    {
+        this->m_raw = other;
+        this->checkPointer();
+        return *this;
+    }
+
+    template<typename U>
     WeakMember& operator=(U* other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
     template<typename U>
     WeakMember& operator=(const RawPtr<U>& other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
     WeakMember& operator=(std::nullptr_t)
     {
         this->m_raw = nullptr;
         return *this;
     }
 
 private:
     T** cell() const { return const_cast<T**>(&this->m_raw); }
 
     template<typename Derived> friend class VisitorHelper;
 };
 
-// Comparison operators between (Weak)Members and Persistents
+// UntracedMember is actually a raw pointer.
+// It is allowed to store a pointer to an object on oilpan heap,
+// and it is also allowed to store UntracedMember in off heap Vector.
+// UntracedMember does not keep the pointee object alive, so if you use
+// UntracedMember, you must guarantee that the pointee object is alive in
+// some reason.
+// TODO(peria): Enable to store UntracedMember in hash collections. (i.e. HashSet)
+template<typename T>
+class UntracedMember {

[haraken, 2015/10/14 09:39:53]

I'm just curious but would it be possible to make UntracedMember inherit from
Member? Then maybe can we decrease the code duplication? (I should have asked
this earlier... sorry :-/)

[peria, 2015/10/15 02:13:15]

Done.

+public:
+    UntracedMember() : m_raw(nullptr)
+    {
+    }
+
+    UntracedMember(std::nullptr_t) : m_raw(nullptr)
+    {
+    }
+
+    UntracedMember(const UntracedMember& other) : m_raw(other)
+    {
+        checkPointer();
+    }
+
+    template<typename U>
+    UntracedMember(const UntracedMember<U>& other) : m_raw(other)
+    {
+        checkPointer();
+    }
+
+    UntracedMember(T* raw) : m_raw(raw)
+    {
+        checkPointer();
+    }
+
+    template<typename U>
+    UntracedMember(const RawPtr<U>& other) : m_raw(other.get())
+    {
+        checkPointer();
+    }
+
+    template<typename U>
+    UntracedMember(const Persistent<U>& other) : m_raw(other)
+    {
+        checkPointer();
+    }
+
+    template<typename U>
+    UntracedMember(const Member<U>& other) : m_raw(other)
+    {
+        checkPointer();
+    }
+
+    UntracedMember(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1))
+    {
+    }
+
+    bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
+
+    T* release()
+    {
+        T* result = m_raw;
+        m_raw = nullptr;
+        return result;
+    }
+
+    bool operator!() const { return !m_raw; }
+
+    operator T*() const { return m_raw; }
+
+    T* operator->() const { return m_raw; }
+    T& operator*() const { return *m_raw; }
+    template<typename U>
+    operator RawPtr<U>() const { return m_raw; }
+
+    template<typename U>
+    UntracedMember& operator=(const UntracedMember<U>& other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    template<typename U>
+    UntracedMember& operator=(const Persistent<U>& other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    template<typename U>
+    UntracedMember& operator=(const Member<U>& other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    template<typename U>
+    UntracedMember& operator=(RawPtr<U> other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    template<typename U>
+    UntracedMember& operator=(U* other)
+    {
+        m_raw = other;
+        checkPointer();
+        return *this;
+    }
+
+    UntracedMember& operator=(std::nullptr_t)
+    {
+        m_raw = nullptr;
+        return *this;
+    }
+
+    void swap(UntracedMember<T>& other)
+    {
+        std::swap(m_raw, other.m_raw);
+        checkPointer();
+    }
+
+    T* get() const { return m_raw; }
+
+    void clear() { m_raw = nullptr; }
+
+
+protected:
+    void checkPointer()
+    {
+#if ENABLE(ASSERT)
+        if (!m_raw)
+            return;
+
+        // TODO(haraken): What we really want to check here is that the pointer
+        // is a traceable object. In other words, 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.
+        //
+        // We can check it by calling Heap::isHeapObjectAlive(m_raw),
+        // but we cannot call it here because it requires to include T.h.
+        // So we currently only try to implement the check for (a), but do
+        // not insist that T's definition is in scope.
+        if (IsFullyDefined<T>::value && !IsGarbageCollectedMixin<T>::value)
+            ASSERT(HeapObjectHeader::fromPayload(m_raw)->checkHeader());
+#endif
+    }
+
+    T* m_raw;
+};
+
+// Comparison operators between (Weak)Members, Persistents, and UntracedMembers.
 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 UntracedMember<T>& a, const UntracedMember<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const UntracedMember<T>& a, const UntracedMember<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(); }
-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 UntracedMember<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const Member<T>& a, const UntracedMember<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const UntracedMember<T>& a, const Member<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const UntracedMember<T>& a, const Member<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const UntracedMember<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const UntracedMember<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const UntracedMember<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const UntracedMember<U>& b) { return a.get() != b.get(); }
 
 template<typename T>
 class DummyBase {
 public:
     DummyBase() { }
     ~DummyBase() { }
 };
 
 // CPP-defined type names for the transition period where we want to
 // support both reference counting and garbage collection based on a
@@ skipping 27 matching lines @@
 #define RefPtrWillBePersistent blink::Persistent
 #define RefPtrWillBeRawPtr WTF::RawPtr
 #define RefPtrWillBeMember blink::Member
 #define RefPtrWillBeWeakMember blink::WeakMember
 #define RefPtrWillBeWeakPersistent blink::WeakPersistent
 #define RefPtrWillBeCrossThreadPersistent blink::CrossThreadPersistent
 #define RawPtrWillBeMember blink::Member
 #define RawPtrWillBePersistent blink::Persistent
 #define RawPtrWillBeWeakMember blink::WeakMember
 #define RawPtrWillBeWeakPersistent blink::WeakPersistent
+#define RawPtrWillBeUntracedMember blink::UntracedMember
 #define OwnPtrWillBeCrossThreadPersistent blink::CrossThreadPersistent
 #define OwnPtrWillBeMember blink::Member
 #define OwnPtrWillBePersistent blink::Persistent
 #define OwnPtrWillBeRawPtr WTF::RawPtr
 #define PassOwnPtrWillBeRawPtr WTF::RawPtr
 #define WeakPtrWillBeCrossThreadWeakPersistent blink::CrossThreadWeakPersistent
 #define WeakPtrWillBeMember blink::Member
 #define WeakPtrWillBeRawPtr WTF::RawPtr
 #define WeakPtrWillBeWeakMember blink::WeakMember
 #define WeakPtrWillBeWeakPersistent blink::WeakPersistent
@@ skipping 63 matching lines @@
 #define RefPtrWillBePersistent WTF::RefPtr
 #define RefPtrWillBeRawPtr WTF::RefPtr
 #define RefPtrWillBeMember WTF::RefPtr
 #define RefPtrWillBeWeakMember WTF::RefPtr
 #define RefPtrWillBeWeakPersistent WTF::RefPtr
 #define RefPtrWillBeCrossThreadPersistent WTF::RefPtr
 #define RawPtrWillBeMember WTF::RawPtr
 #define RawPtrWillBePersistent WTF::RawPtr
 #define RawPtrWillBeWeakMember WTF::RawPtr
 #define RawPtrWillBeWeakPersistent WTF::RawPtr
+#define RawPtrWillBeUntracedMember WTF::RawPtr
 #define OwnPtrWillBeCrossThreadPersistent WTF::OwnPtr
 #define OwnPtrWillBeMember WTF::OwnPtr
 #define OwnPtrWillBePersistent WTF::OwnPtr
 #define OwnPtrWillBeRawPtr WTF::OwnPtr
 #define PassOwnPtrWillBeRawPtr WTF::PassOwnPtr
 #define WeakPtrWillBeCrossThreadWeakPersistent WTF::WeakPtr
 #define WeakPtrWillBeMember WTF::WeakPtr
 #define WeakPtrWillBeRawPtr WTF::WeakPtr
 #define WeakPtrWillBeWeakMember WTF::WeakPtr
 #define WeakPtrWillBeWeakPersistent WTF::WeakPtr
@@ skipping 170 matching lines @@
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::WeakMember<T>> : VectorTraitsBase<blink::WeakMember<T>> {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
+template <typename T> struct VectorTraits<blink::UntracedMember<T>> : VectorTraitsBase<blink::UntracedMember<T>> {
+    static const bool needsDestruction = false;
+    static const bool canInitializeWithMemset = true;
+    static const bool canClearUnusedSlotsWithMemset = true;
+    static const bool canMoveWithMemcpy = true;
+};
+
 template <typename T> struct VectorTraits<blink::HeapVector<T, 0>> : VectorTraitsBase<blink::HeapVector<T, 0>> {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::HeapDeque<T, 0>> : VectorTraitsBase<blink::HeapDeque<T, 0>> {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
@@ skipping 71 matching lines @@
     static bool traceInCollection(VisitorDispatcher visitor, blink::WeakMember<T>& weakMember, ShouldWeakPointersBeMarkedStrongly strongify)
     {
         if (strongify == WeakPointersActStrong) {
             visitor->trace(weakMember.get()); // Strongified visit.
             return false;
         }
         return !blink::Heap::isHeapObjectAlive(weakMember);
     }
 };
 
+template<typename T> struct HashTraits<blink::UntracedMember<T>> : SimpleClassHashTraits<blink::UntracedMember<T>> {
+    static const bool needsDestruction = false;
+    // FIXME: The distinction between PeekInType and PassInType is there for
+    // the sake of the reference counting handles. When they are gone the two
+    // types can be merged into PassInType.
+    // FIXME: Implement proper const'ness for iterator types.
+    using PeekInType = RawPtr<T>;
+    using PassInType = RawPtr<T>;
+    using IteratorGetType = blink::UntracedMember<T>*;
+    using IteratorConstGetType = const blink::UntracedMember<T>*;
+    using IteratorReferenceType = blink::UntracedMember<T>&;
+    using IteratorConstReferenceType = const blink::UntracedMember<T>&;
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
+    // FIXME: Similarly, there is no need for a distinction between PeekOutType
+    // and PassOutType without reference counting.
+    using PeekOutType = T*;
+    using PassOutType = T*;
+
+    template<typename U>
+    static void store(const U& value, blink::UntracedMember<T>& storage) { storage = value; }
+
+    static PeekOutType peek(const blink::UntracedMember<T>& value) { return value; }
+    static PassOutType passOut(const blink::UntracedMember<T>& value) { return value; }
+};
+
 template<typename T> struct PtrHash<blink::Member<T>> : PtrHash<T*> {
     template<typename U>
     static unsigned hash(const U& key) { return PtrHash<T*>::hash(key); }
     static bool equal(T* a, const blink::Member<T>& b) { return a == b; }
     static bool equal(const blink::Member<T>& a, T* b) { return a == b; }
     template<typename U, typename V>
     static bool equal(const U& a, const V& b) { return a == b; }
 };
 
 template<typename T> struct PtrHash<blink::WeakMember<T>> : PtrHash<blink::Member<T>> {
 };
 
 // PtrHash is the default hash for hash tables with members.
 template<typename T> struct DefaultHash<blink::Member<T>> {
     using Hash = PtrHash<blink::Member<T>>;
 };
 
 template<typename T> struct DefaultHash<blink::WeakMember<T>> {
     using Hash = PtrHash<blink::WeakMember<T>>;
 };
 
+template<typename T> struct DefaultHash<blink::UntracedMember<T>> {
+    using Hash = PtrHash<blink::UntracedMember<T>>;
+};
+
 template<typename T>
 struct NeedsTracing<blink::Member<T>> {
     static const bool value = true;
 };
 
 template<typename T>
 struct IsWeak<blink::WeakMember<T>> {
     static const bool value = true;
 };
 
@@ skipping 58 matching lines @@
     // TODO(sof): extend WTF::FunctionWrapper call overloading to also handle (CrossThread)WeakPersistent.
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif