Rename and improve "traceable" templates.

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 337 matching lines @@
 
     T* buffer() { return m_buffer; }
     const T* buffer() const { return m_buffer; }
     size_t capacity() const { return m_capacity; }
 
     void clearUnusedSlots(T* from, T* to)
     {
         // If the vector backing is garbage-collected and needs tracing or
         // finalizing, we clear out the unused slots so that the visitor or the
         // finalizer does not cause a problem when visiting the unused slots.
-        VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || NeedsTracingTrait<VectorTraits<T>>::value), T>::clear(from, to);
+        VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || IsTraceableInCollectionTrait<VectorTraits<T>>::value), T>::clear(from, to);
     }
 
     void checkUnusedSlots(const T* from, const T* to)
     {
 #if ENABLE(ASSERT) && !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
-        VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || NeedsTracingTrait<VectorTraits<T>>::value), T>::checkCleared(from, to);
+        VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || IsTraceableInCollectionTrait<VectorTraits<T>>::value), T>::checkCleared(from, to);
 #endif
     }
 
     // |end| is exclusive, a la STL.
     struct OffsetRange final {
         OffsetRange() : begin(0), end(0) { }
         explicit OffsetRange(size_t begin, size_t end) : begin(begin), end(end) { ASSERT(begin <= end); }
         bool empty() const { return begin == end; }
         size_t begin;
         size_t end;
@@ skipping 396 matching lines @@
     typedef T value_type;
 
     typedef T* iterator;
     typedef const T* const_iterator;
     typedef std::reverse_iterator<iterator> reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     Vector()
     {
         static_assert(!std::is_polymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
-        static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !NeedsTracing<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Vector");
+        static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !IsTraceable<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Vector");
         static_assert(Allocator::isGarbageCollected || !IsPointerToGarbageCollectedType<T>::value, "Cannot put raw pointers to garbage-collected classes into an off-heap Vector.  Use HeapVector<Member<T>> instead.");
 
         ANNOTATE_NEW_BUFFER(begin(), capacity(), 0);
         m_size = 0;
     }
 
     explicit Vector(size_t size)
         : Base(size)
     {
         static_assert(!std::is_polymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
-        static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !NeedsTracing<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Vector");
+        static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !IsTraceable<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Vector");
         static_assert(Allocator::isGarbageCollected || !IsPointerToGarbageCollectedType<T>::value, "Cannot put raw pointers to garbage-collected classes into an off-heap Vector.  Use HeapVector<Member<T>> instead.");
 
         ANNOTATE_NEW_BUFFER(begin(), capacity(), size);
         m_size = size;
         TypeOperations::initialize(begin(), end());
     }
 
     // Off-GC-heap vectors: Destructor should be called.
     // On-GC-heap vectors: Destructor should be called for inline buffers (if
     // any) but destructor shouldn't be called for vector backing since it is
@@ skipping 713 matching lines @@
         // This is a performance optimization for a case where the buffer has
         // been already traced by somewhere. This can happen if the conservative
         // scanning traced an on-stack (false-positive or real) pointer to the
         // HeapVector, and then visitor->trace() traces the HeapVector.
         if (Allocator::isHeapObjectAlive(buffer()))
             return;
         Allocator::markNoTracing(visitor, buffer());
     }
     const T* bufferBegin = buffer();
     const T* bufferEnd = buffer() + size();
-    if (NeedsTracingTrait<VectorTraits<T>>::value) {
+    if (IsTraceableInCollectionTrait<VectorTraits<T>>::value) {
         for (const T* bufferEntry = bufferBegin; bufferEntry != bufferEnd; bufferEntry++)
             Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
         checkUnusedSlots(buffer() + size(), buffer() + capacity());
     }
 }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h