Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/ThreadingTraits.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 ThreadingTraits_h
 #define ThreadingTraits_h
 
+#include "wtf/Allocator.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"
 
@@ skipping 15 matching lines @@
 // Remove them.
 class Node;
 class NodeList;
 
 template<typename T,
     bool mainThreadOnly = WTF::IsSubclass<typename std::remove_const<T>::type, Node>::value
         || WTF::IsSubclass<typename std::remove_const<T>::type, NodeList>::value> struct DefaultThreadingTrait;
 
 template<typename T>
 struct DefaultThreadingTrait<T, false> {
+    STATIC_ONLY(DefaultThreadingTrait);
     static const ThreadAffinity Affinity = AnyThread;
 };
 
 template<typename T>
 struct DefaultThreadingTrait<T, true> {
+    STATIC_ONLY(DefaultThreadingTrait);
     static const ThreadAffinity Affinity = MainThreadOnly;
 };
 
 class HeapAllocator;
 template<typename Table> class HeapHashTableBacking;
 template<typename T, typename Traits> class HeapVectorBacking;
 template<typename T> class Member;
 template<typename T> class WeakMember;
 
 template<typename T>
 struct ThreadingTrait {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = DefaultThreadingTrait<T>::Affinity;
 };
 
 template<typename U> class ThreadingTrait<const U> : public ThreadingTrait<U> { };
 
 template<typename T>
 struct ThreadingTrait<Member<T>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T>
 struct ThreadingTrait<WeakMember<T>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct ThreadingTrait<HashMap<Key, Value, T, U, V, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity =
         (ThreadingTrait<Key>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename First, typename Second>
 struct ThreadingTrait<WTF::KeyValuePair<First, Second>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity =
         (ThreadingTrait<First>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Second>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HashSet<T, U, V, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, typename Traits>
 struct ThreadingTrait<HeapVectorBacking<T, Traits>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HashCountedSet<T, U, V, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename Table>
 struct ThreadingTrait<HeapHashTableBacking<Table>> {
+    STATIC_ONLY(ThreadingTrait);
     using Key = typename Table::KeyType;
     using Value = typename Table::ValueType;
     static const ThreadAffinity Affinity =
         (ThreadingTrait<Key>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename T, typename U, typename V, typename W, typename X> class HeapHashMap;
 template<typename T, typename U, typename V> class HeapHashSet;
 template<typename T, size_t inlineCapacity> class HeapVector;
 template<typename T, size_t inlineCapacity> class HeapDeque;
 template<typename T, typename U, typename V> class HeapHashCountedSet;
 
 template<typename T, typename U, typename V, typename W, typename X>
-struct ThreadingTrait<HeapHashMap<T, U, V, W, X>> : public ThreadingTrait<HashMap<T, U, V, W, X, HeapAllocator>> { };
+struct ThreadingTrait<HeapHashMap<T, U, V, W, X>> : public ThreadingTrait<HashMap<T, U, V, W, X, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
+};
 template<typename T, typename U, typename V>
-struct ThreadingTrait<HeapHashSet<T, U, V>> : public ThreadingTrait<HashSet<T, U, V, HeapAllocator>> { };
+struct ThreadingTrait<HeapHashSet<T, U, V>> : public ThreadingTrait<HashSet<T, U, V, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
+};
 template<typename T, size_t inlineCapacity>
-struct ThreadingTrait<HeapVector<T, inlineCapacity>> : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
+struct ThreadingTrait<HeapVector<T, inlineCapacity>> : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
+};
 template<typename T, size_t inlineCapacity>
-struct ThreadingTrait<HeapDeque<T, inlineCapacity>> : public ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
+struct ThreadingTrait<HeapDeque<T, inlineCapacity>> : public ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
+};
 template<typename T, typename U, typename V>
-struct ThreadingTrait<HeapHashCountedSet<T, U, V>> : public ThreadingTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
+struct ThreadingTrait<HeapHashCountedSet<T, U, V>> : public ThreadingTrait<HashCountedSet<T, U, V, HeapAllocator>> {
+    STATIC_ONLY(ThreadingTrait);
+};
 
 } // namespace blink
 
 #endif