Rename and improve "traceable" templates.

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

 // Copyright 2015 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 TraceTraits_h
 #define TraceTraits_h
 
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
@@ skipping 86 matching lines @@
         // the dangling pointer.
         // Release builds don't have the ASSERT, but it is OK because
         // release builds will crash at the following self->adjustAndMark
         // because all the entries of the orphaned arenas are zeroed out and
         // thus the item does not have a valid vtable.
         ASSERT(!pageFromObject(self)->orphaned());
         self->adjustAndMark(visitor);
     }
 };
 
-template<typename T, bool needsTracing>
+template<typename T, bool isTraceable>
 struct TraceIfEnabled;
 
 template<typename T>
 struct TraceIfEnabled<T, false>  {
     STATIC_ONLY(TraceIfEnabled);
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher, T&)
     {
-        static_assert(!WTF::NeedsTracing<T>::value, "T should not be traced");
+        static_assert(!WTF::IsTraceable<T>::value, "T should not be traced");
     }
 };
 
 template<typename T>
 struct TraceIfEnabled<T, true> {
     STATIC_ONLY(TraceIfEnabled);
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, T& t)
     {
-        static_assert(WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value, "T should be traced");
+        static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
         visitor->trace(t);
     }
 };
 
-template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct TraceCollectionIfEnabled;
+template<bool isTraceable, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct TraceCollectionIfEnabled;
 
 template<WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceCollectionIfEnabled<false, WTF::NoWeakHandlingInCollections, strongify, T, Traits> {
     STATIC_ONLY(TraceCollectionIfEnabled);
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher, T&)
     {
-        static_assert(!WTF::NeedsTracingTrait<Traits>::value, "Traits should not be traced");
+        static_assert(!WTF::IsTraceableInCollectionTrait<Traits>::value, "T should not be traced");
         return false;
     }
 };
 
-template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
+template<bool isTraceable, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceCollectionIfEnabled {
     STATIC_ONLY(TraceCollectionIfEnabled);
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, T& t)
     {
-        static_assert(WTF::NeedsTracingTrait<Traits>::value || weakHandlingFlag == WTF::WeakHandlingInCollections, "Traits should be traced");
+        static_assert(WTF::IsTraceableInCollectionTrait<Traits>::value || weakHandlingFlag == WTF::WeakHandlingInCollections, "Traits should be traced");
         return WTF::TraceInCollectionTrait<weakHandlingFlag, strongify, T, Traits>::trace(visitor, t);
     }
 };
 
 // The TraceTrait is used to specify how to mark an object pointer and
 // how to trace all of the pointers in the object.
 //
 // By default, the 'trace' method implemented on an object itself is
 // used to trace the pointers to other heap objects inside the object.
 //
@@ skipping 19 matching lines @@
     {
         AdjustAndMarkTrait<T>::mark(visitor, t);
     }
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 template<typename T>
 void TraceTrait<T>::trace(Visitor* visitor, void* self)
 {
-    static_assert(WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value, "T should be traced");
+    static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
     if (visitor->getMarkingMode() == Visitor::GlobalMarking) {
         // Switch to inlined global marking dispatch.
         static_cast<T*>(self)->trace(InlinedGlobalMarkingVisitor(visitor->state()));
     } else {
         static_cast<T*>(self)->trace(visitor);
     }
 }
 
 template<typename T>
 void TraceTrait<T>::trace(InlinedGlobalMarkingVisitor visitor, void* self)
 {
-    static_assert(WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value, "T should be traced");
+    static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
     static_cast<T*>(self)->trace(visitor);
 }
 
 template<typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits>> {
     STATIC_ONLY(TraceTrait);
     using Backing = HeapVectorBacking<T, Traits>;
 
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, void* self)
     {
-        static_assert(!WTF::IsWeak<T>::value, "weakness in HeapVectors and Deques are not supported");
-        if (WTF::NeedsTracingTrait<Traits>::value)
+        static_assert(!WTF::IsWeak<T>::value, "weakness in HeapVectors and HeapDeques are not supported");
+        if (WTF::IsTraceableInCollectionTrait<Traits>::value)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, HeapVectorBacking<T, Traits>, void>::trace(visitor, self);
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const Backing* backing)
     {
         AdjustAndMarkTrait<Backing>::mark(visitor, backing);
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner.  This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries.  When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
 template<typename Table>
 struct TraceTrait<HeapHashTableBacking<Table>> {
     STATIC_ONLY(TraceTrait);
     using Backing = HeapHashTableBacking<Table>;
     using Traits = typename Table::ValueTraits;
 
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, void* self)
     {
-        if (WTF::NeedsTracingTrait<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
+        if (WTF::IsTraceableInCollectionTrait<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActStrong, Backing, void>::trace(visitor, self);
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const Backing* backing)
     {
         AdjustAndMarkTrait<Backing>::mark(visitor, backing);
     }
 };
 
 // This trace trait for std::pair will null weak members if their referent is
 // collected. If you have a collection that contain weakness it does not remove
 // entries from the collection that contain nulled weak members.
 template<typename T, typename U>
 class TraceTrait<std::pair<T, U>> {
     STATIC_ONLY(TraceTrait);
 public:
-    static const bool firstNeedsTracing = WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value;
-    static const bool secondNeedsTracing = WTF::NeedsTracing<U>::value || WTF::IsWeak<U>::value;
+    static const bool firstIsTraceable = WTF::IsTraceable<T>::value;
+    static const bool secondIsTraceable = WTF::IsTraceable<U>::value;
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, std::pair<T, U>* pair)
     {
-        TraceIfEnabled<T, firstNeedsTracing>::trace(visitor, pair->first);
-        TraceIfEnabled<U, secondNeedsTracing>::trace(visitor, pair->second);
+        TraceIfEnabled<T, firstIsTraceable>::trace(visitor, pair->first);
+        TraceIfEnabled<U, secondIsTraceable>::trace(visitor, pair->second);
     }
 };
 
 // If eager tracing leads to excessively deep |trace()| call chains (and
 // the system stack usage that this brings), the marker implementation will
 // switch to using an explicit mark stack. Recursive and deep object graphs
 // are uncommon for Blink objects.
 //
 // A class type can opt out of eager tracing by declaring a TraceEagerlyTrait<>
 // specialization, mapping the trait's |value| to |false| (see the
@@ skipping 71 matching lines @@
 };
 
 template<typename ValueArg, size_t inlineCapacity> class HeapListHashSetAllocator;
 template<typename T, size_t inlineCapacity>
 class TraceEagerlyTrait<WTF::ListHashSetNode<T, HeapListHashSetAllocator<T, inlineCapacity>>> {
     STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = false;
 };
 
-template <typename T> struct RemoveHeapPointerWrapperTypes {
-    STATIC_ONLY(RemoveHeapPointerWrapperTypes);
-    using Type = typename WTF::RemoveTemplate<typename WTF::RemoveTemplate<T, Member>::Type, WeakMember>::Type;
-};
-
-// FIXME: Oilpan: TraceIfNeeded should be implemented ala:
-// NeedsTracing<T>::value || IsWeakMember<T>::value. It should not need to test
-// raw pointer types.
 template<typename T>
-struct TraceIfNeeded : public TraceIfEnabled<T, WTF::NeedsTracing<T>::value || IsGarbageCollectedType<typename RemoveHeapPointerWrapperTypes<typename std::remove_pointer<T>::type>::Type>::value> {
+struct TraceIfNeeded : public TraceIfEnabled<T, WTF::IsTraceable<T>::value> {
     STATIC_ONLY(TraceIfNeeded);
 };
 
 } // namespace blink
 
 namespace WTF {
 
 // Catch-all for types that have a way to trace that don't have special
 // handling for weakness in collections.  This means that if this type
 // contains WeakMember fields, they will simply be zeroed, but the entry
 // will not be removed from the collection.  This always happens for
 // things in vectors, which don't currently support special handling of
 // weak elements.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, T, Traits> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, T& t)
     {
-        ASSERT(NeedsTracingTrait<Traits>::value);
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value);
         visitor->trace(t);
         return false;
     }
 };
 
 // Catch-all for things that have HashTrait support for tracing with weakness.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, T, Traits> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, T& t)
@@ skipping 17 matching lines @@
         //   traces only slots that are not zeroed out. This is because if
         //   the object has a vtable, the zeroed slot means that it is
         //   an unused slot (Remember that the unused slots are guaranteed
         //   to be zeroed out by VectorUnusedSlotClearer).
         //
         // - An object that can be initialized with memset. In this case,
         //   HeapVectorBacking traces all slots including unused slots.
         //   This is fine because the fact that the object can be initialized
         //   with memset indicates that it is safe to treat the zerod slot
         //   as a valid object.
-        static_assert(!NeedsTracingTrait<Traits>::value || Traits::canClearUnusedSlotsWithMemset || std::is_polymorphic<T>::value, "HeapVectorBacking doesn't support objects that cannot be cleared as unused with memset.");
+        static_assert(!IsTraceableInCollectionTrait<Traits>::value || Traits::canClearUnusedSlotsWithMemset || std::is_polymorphic<T>::value, "HeapVectorBacking doesn't support objects that cannot be cleared as unused with memset.");
 
         // This trace method is instantiated for vectors where
-        // NeedsTracingTrait<Traits>::value is false, but the trace method
+        // IsTraceableInCollectionTrait<Traits>::value is false, but the trace method
         // should not be called. Thus we cannot static-assert
-        // NeedsTracingTrait<Traits>::value but should runtime-assert it.
-        ASSERT(NeedsTracingTrait<Traits>::value);
+        // IsTraceableInCollectionTrait<Traits>::value but should runtime-assert it.
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value);
 
         T* array = reinterpret_cast<T*>(self);
         blink::HeapObjectHeader* header = blink::HeapObjectHeader::fromPayload(self);
         ASSERT(header->checkHeader());
         // Use the payload size as recorded by the heap to determine how many
         // elements to trace.
         size_t length = header->payloadSize() / sizeof(T);
         if (std::is_polymorphic<T>::value) {
             for (size_t i = 0; i < length; ++i) {
                 if (blink::vTableInitialized(&array[i]))
-                    blink::TraceIfEnabled<T, NeedsTracingTrait<Traits>::value>::trace(visitor, array[i]);
+                    blink::TraceIfEnabled<T, IsTraceableInCollectionTrait<Traits>::value>::trace(visitor, array[i]);
             }
         } else {
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
             // As commented above, HeapVectorBacking can trace unused slots
             // (which are already zeroed out).
             ANNOTATE_CHANGE_SIZE(array, length, 0, length);
 #endif
             for (size_t i = 0; i < length; ++i)
-                blink::TraceIfEnabled<T, NeedsTracingTrait<Traits>::value>::trace(visitor, array[i]);
+                blink::TraceIfEnabled<T, IsTraceableInCollectionTrait<Traits>::value>::trace(visitor, array[i]);
         }
         return false;
     }
 };
 
 // This trace method is used only for on-stack HeapHashTables found in
 // conservative scanning. On-heap HeapHashTables are traced by HashTable::trace.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Table>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapHashTableBacking<Table>, void> {
     using Value = typename Table::ValueType;
     using Traits = typename Table::ValueTraits;
 
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, void* self)
     {
         static_assert(strongify == WTF::WeakPointersActStrong, "An on-stack HeapHashTable needs to be visited strongly.");
 
-        ASSERT(NeedsTracingTrait<Traits>::value || Traits::weakHandlingFlag == WeakHandlingInCollections);
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value || Traits::weakHandlingFlag == WeakHandlingInCollections);
         Value* array = reinterpret_cast<Value*>(self);
         blink::HeapObjectHeader* header = blink::HeapObjectHeader::fromPayload(self);
         ASSERT(header->checkHeader());
         // Use the payload size as recorded by the heap to determine how many
         // elements to trace.
         size_t length = header->payloadSize() / sizeof(Value);
         for (size_t i = 0; i < length; ++i) {
             if (!HashTableHelper<Value, typename Table::ExtractorType, typename Table::KeyTraitsType>::isEmptyOrDeletedBucket(array[i]))
-                blink::TraceCollectionIfEnabled<NeedsTracingTrait<Traits>::value, Traits::weakHandlingFlag, strongify, Value, Traits>::trace(visitor, array[i]);
+                blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<Traits>::value, Traits::weakHandlingFlag, strongify, Value, Traits>::trace(visitor, array[i]);
         }
         return false;
     }
 };
 
 // This specialization of TraceInCollectionTrait is for the backing of
 // HeapListHashSet.  This is for the case that we find a reference to the
 // backing from the stack.  That probably means we have a GC while we are in a
 // ListHashSet method since normal API use does not put pointers to the backing
 // on the stack.
@@ skipping 24 matching lines @@
 };
 
 // Key value pairs, as used in HashMap.  To disambiguate template choice we have
 // to have two versions, first the one with no special weak handling, then the
 // one with weak handling.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Key, typename Value, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, KeyValuePair<Key, Value>, Traits>  {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, KeyValuePair<Key, Value>& self)
     {
-        ASSERT(NeedsTracingTrait<Traits>::value);
-        blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::KeyTraits>::value, NoWeakHandlingInCollections, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
-        blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::ValueTraits>::value, NoWeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value);
+        blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::KeyTraits>::value, NoWeakHandlingInCollections, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
+        blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::ValueTraits>::value, NoWeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
         return false;
     }
 };
 
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Key, typename Value, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, KeyValuePair<Key, Value>, Traits> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, KeyValuePair<Key, Value>& self)
     {
         // This is the core of the ephemeron-like functionality.  If there is
         // weakness on the key side then we first check whether there are
         // dead weak pointers on that side, and if there are we don't mark the
         // value side (yet).  Conversely if there is weakness on the value side
         // we check that first and don't mark the key side yet if we find dead
         // weak pointers.
         // Corner case: If there is weakness on both the key and value side,
         // and there are also strong pointers on the both sides then we could
         // unexpectedly leak.  The scenario is that the weak pointer on the key
         // side is alive, which causes the strong pointer on the key side to be
         // marked.  If that then results in the object pointed to by the weak
         // pointer on the value side being marked live, then the whole
         // key-value entry is leaked.  To avoid unexpected leaking, we disallow
         // this case, but if you run into this assert, please reach out to Blink
         // reviewers, and we may relax it.
         const bool keyIsWeak = Traits::KeyTraits::weakHandlingFlag == WeakHandlingInCollections;
         const bool valueIsWeak = Traits::ValueTraits::weakHandlingFlag == WeakHandlingInCollections;
-        const bool keyHasStrongRefs = NeedsTracingTrait<typename Traits::KeyTraits>::value;
-        const bool valueHasStrongRefs = NeedsTracingTrait<typename Traits::ValueTraits>::value;
+        const bool keyHasStrongRefs = IsTraceableInCollectionTrait<typename Traits::KeyTraits>::value;
+        const bool valueHasStrongRefs = IsTraceableInCollectionTrait<typename Traits::ValueTraits>::value;
         static_assert(!keyIsWeak || !valueIsWeak || !keyHasStrongRefs || !valueHasStrongRefs, "this configuration is disallowed to avoid unexpected leaks");
         if ((valueIsWeak && !keyIsWeak) || (valueIsWeak && keyIsWeak && !valueHasStrongRefs)) {
             // Check value first.
-            bool deadWeakObjectsFoundOnValueSide = blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
+            bool deadWeakObjectsFoundOnValueSide = blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
             if (deadWeakObjectsFoundOnValueSide)
                 return true;
-            return blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
+            return blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
         }
         // Check key first.
-        bool deadWeakObjectsFoundOnKeySide = blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
+        bool deadWeakObjectsFoundOnKeySide = blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
         if (deadWeakObjectsFoundOnKeySide)
             return true;
-        return blink::TraceCollectionIfEnabled<NeedsTracingTrait<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
+        return blink::TraceCollectionIfEnabled<IsTraceableInCollectionTrait<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
     }
 };
 
 // Nodes used by LinkedHashSet.  Again we need two versions to disambiguate the
 // template.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, typename Allocator, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, LinkedHashSetNode<Value, Allocator>, Traits> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, LinkedHashSetNode<Value, Allocator>& self)
     {
-        ASSERT(NeedsTracingTrait<Traits>::value);
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value);
         return TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.m_value);
     }
 };
 
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, typename Allocator, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, LinkedHashSetNode<Value, Allocator>, Traits> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, LinkedHashSetNode<Value, Allocator>& self)
     {
         return TraceInCollectionTrait<WeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.m_value);
     }
 };
 
 // ListHashSetNode pointers (a ListHashSet is implemented as a hash table of
 // these pointers).
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, size_t inlineCapacity, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, ListHashSetNode<Value, blink::HeapListHashSetAllocator<Value, inlineCapacity>>*, Traits> {
     using Node = ListHashSetNode<Value, blink::HeapListHashSetAllocator<Value, inlineCapacity>>;
 
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, Node* node)
     {
-        ASSERT(NeedsTracingTrait<Traits>::value);
+        DCHECK(IsTraceableInCollectionTrait<Traits>::value);
         traceListHashSetValue(visitor, node->m_value);
         // Just mark the node without tracing because we already traced the
         // contents, and there is no need to trace the next and prev fields
         // since iterating over the hash table backing will find the whole
         // chain.
         visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 #endif