Make platform/heap to use USING_FAST_MALLOC.

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"
 #include "platform/heap/Visitor.h"
+#include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/HashCountedSet.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTable.h"
 #include "wtf/LinkedHashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/TypeTraits.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 template<typename T> class CrossThreadPersistent;
 template<typename T> class CrossThreadWeakPersistent;
 template<typename T> class Member;
 template<typename T> class TraceTrait;
 template<typename T> class WeakMember;
 template<typename T> class WeakPersistent;
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class AdjustAndMarkTrait;
 
 template<typename T>
 class AdjustAndMarkTrait<T, false> {
+    STATIC_ONLY(AdjustAndMarkTrait);
 public:
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
 #if ENABLE(ASSERT)
         assertObjectHasGCInfo(const_cast<T*>(t), GCInfoTrait<T>::index());
 #endif
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
@@ skipping 21 matching lines @@
                 }
                 return;
             }
         }
         visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
     }
 };
 
 template<typename T>
 class AdjustAndMarkTrait<T, true> {
+    STATIC_ONLY(AdjustAndMarkTrait);
 public:
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* self)
     {
         if (!self)
             return;
 
         // If you hit this ASSERT, it means that there is a dangling pointer
         // from a live thread heap to a dead thread heap. We must eliminate
         // 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 heaps 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>
 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");
     }
 };
 
 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");
         visitor->trace(t);
     }
 };
 
 template<bool needsTracing, 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");
         return false;
     }
 };
 
 template<bool needsTracing, 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");
         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.
 //
 // However, the TraceTrait can be specialized to use a different
 // implementation. A common case where a TraceTrait specialization is
 // needed is when multiple inheritance leads to pointers that are not
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
+    STATIC_ONLY(TraceTrait);
 public:
     static void trace(Visitor*, void* self);
     static void trace(InlinedGlobalMarkingVisitor, void* self);
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
         AdjustAndMarkTrait<T>::mark(visitor, t);
     }
 };
@@ skipping 14 matching lines @@
 
 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_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)
             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)
             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;
     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);
     }
 };
@@ skipping 15 matching lines @@
 // should invoke |trace()| on not-yet-marked objects deriving from class T
 // right away, and not queue their trace callbacks on its marker stack,
 // which it will do if |value| is |false|.
 //
 // The trait can be declared to enable/disable eager tracing for a class T
 // and any of its subclasses, or just to the class T, but none of its
 // subclasses.
 //
 template<typename T>
 class TraceEagerlyTrait {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = true;
 };
 
 // Disable eager tracing for TYPE, but not any of its subclasses.
 #define WILL_NOT_BE_EAGERLY_TRACED_CLASS(TYPE)   \
 template<>                                       \
 class TraceEagerlyTrait<TYPE> {                  \
+    STATIC_ONLY(TraceEagerlyTrait);              \
 public:                                          \
     static const bool value = false;             \
 }
 
 template<typename T>
 class TraceEagerlyTrait<Member<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<WeakMember<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<Persistent<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<WeakPersistent<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<CrossThreadPersistent<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<CrossThreadWeakPersistent<T>> {
+    STATIC_ONLY(TraceEagerlyTrait);
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 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<typename WTF::RemoveTemplate<T, Member>::Type, WeakMember>::Type, RawPtr>::Type;
 };
 
 // FIXME: Oilpan: TraceIfNeeded should be implemented ala:
 // NeedsTracing<T>::value || IsWeakMember<T>::value. It should not need to test
 // raw pointer types. To remove these tests, we may need support for
 // instantiating a template with a RawPtrOrMember'ish template.
 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::NeedsTracing<T>::value || IsGarbageCollectedType<typename RemoveHeapPointerWrapperTypes<typename std::remove_pointer<T>::type>::Type>::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
@@ skipping 223 matching lines @@
         // since iterating over the hash table backing will find the whole
         // chain.
         visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 #endif