Rename and improve "traceable" templates.

third_party/WebKit/Source/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 95 matching lines @@
     void remove(const_iterator&);
 
     void clear();
 
     template <typename Predicate>
     iterator findIf(Predicate&);
 
     template <typename VisitorDispatcher> void trace(VisitorDispatcher);
 
     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 Deque");
+    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 Deque");
     static_assert(Allocator::isGarbageCollected || !IsPointerToGarbageCollectedType<T>::value, "Cannot put raw pointers to garbage-collected classes into a Deque. Use HeapDeque<Member<T>> instead.");
 
 private:
     friend class DequeIteratorBase<T, inlineCapacity, Allocator>;
 
     class BackingBuffer : public VectorBuffer<T, INLINE_CAPACITY, Allocator> {
         WTF_MAKE_NONCOPYABLE(BackingBuffer);
     private:
         using Base = VectorBuffer<T, INLINE_CAPACITY, Allocator>;
         using Base::m_size;
@@ skipping 462 matching lines @@
 
 // This is only called if the allocator is a HeapAllocator. It is used when
 // visiting during a tracing GC.
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename VisitorDispatcher>
 void Deque<T, inlineCapacity, Allocator>::trace(VisitorDispatcher visitor)
 {
     ASSERT(Allocator::isGarbageCollected); // Garbage collector must be enabled.
     const T* bufferBegin = m_buffer.buffer();
     const T* end = bufferBegin + m_end;
-    if (NeedsTracingTrait<VectorTraits<T>>::value) {
+    if (IsTraceableInCollectionTrait<VectorTraits<T>>::value) {
         if (m_start <= m_end) {
             for (const T* bufferEntry = bufferBegin + m_start; bufferEntry != end; bufferEntry++)
                 Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
         } else {
             for (const T* bufferEntry = bufferBegin; bufferEntry != end; bufferEntry++)
                 Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
             const T* bufferEnd = m_buffer.buffer() + m_buffer.capacity();
             for (const T* bufferEntry = bufferBegin + m_start; bufferEntry != bufferEnd; bufferEntry++)
                 Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
         }
     }
     if (m_buffer.hasOutOfLineBuffer())
         Allocator::markNoTracing(visitor, m_buffer.buffer());
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void swap(Deque<T, inlineCapacity, Allocator>& a, Deque<T, inlineCapacity, Allocator>& b)
 {
     a.swap(b);
 }
 
 } // namespace WTF
 
 using WTF::Deque;
 
 #endif // WTF_Deque_h