Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/HeapAllocator.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 HeapAllocator_h
 #define HeapAllocator_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/TraceTraits.h"
+#include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.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 {
 
 // This is a static-only class used as a trait on collections to make them heap
 // allocated.  However see also HeapListHashSetAllocator.
 class PLATFORM_EXPORT HeapAllocator {
+    STATIC_ONLY(HeapAllocator);
 public:
     using Visitor = blink::Visitor;
     static const bool isGarbageCollected = true;
 
     template<typename T>
     static size_t quantizedSize(size_t count)
     {
         RELEASE_ASSERT(count <= maxHeapObjectSize / sizeof(T));
         return Heap::allocationSizeFromSize(count * sizeof(T)) - sizeof(HeapObjectHeader);
     }
@@ skipping 156 matching lines @@
     TraceCollectionIfEnabled<WTF::NeedsTracingTrait<WTF::HashTraits<Value>>::value, WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, Value, WTF::HashTraits<Value>>::trace(visitor, value);
 }
 
 // The inline capacity is just a dummy template argument to match the off-heap
 // allocator.
 // This inherits from the static-only HeapAllocator trait class, but we do
 // declare pointers to instances.  These pointers are always null, and no
 // objects are instantiated.
 template<typename ValueArg, size_t inlineCapacity>
 class HeapListHashSetAllocator : public HeapAllocator {
+    DISALLOW_NEW();
 public:
     using TableAllocator = HeapAllocator;
     using Node = WTF::ListHashSetNode<ValueArg, HeapListHashSetAllocator>;
 
     class AllocatorProvider {
+        DISALLOW_NEW();
     public:
         // For the heap allocation we don't need an actual allocator object, so
         // we just return null.
         HeapListHashSetAllocator* get() const { return 0; }
 
         // No allocator object is needed.
         void createAllocatorIfNeeded() { }
         void releaseAllocator() { }
 
         // There is no allocator object in the HeapListHashSet (unlike in the
@@ skipping 15 matching lines @@
     }
 
     template<typename VisitorDispatcher>
     static void traceValue(VisitorDispatcher visitor, Node* node)
     {
         traceListHashSetValue(visitor, node->m_value);
     }
 };
 
 template<typename T, typename Traits = WTF::VectorTraits<T>> class HeapVectorBacking {
+    DISALLOW_NEW();
 public:
     static void finalize(void* pointer);
     void finalizeGarbageCollectedObject() { finalize(this); }
 };
 
 template<typename T, typename Traits>
 void HeapVectorBacking<T, Traits>::finalize(void* pointer)
 {
     static_assert(Traits::needsDestruction, "Only vector buffers with items requiring destruction should be finalized");
     // See the comment in HeapVectorBacking::trace.
@@ skipping 17 matching lines @@
                 buffer[i].~T();
         }
     } else {
         for (unsigned i = 0; i < length; ++i) {
             buffer[i].~T();
         }
     }
 }
 
 template<typename Table> class HeapHashTableBacking {
+    DISALLOW_NEW();
 public:
     static void finalize(void* pointer);
     void finalizeGarbageCollectedObject() { finalize(this); }
 };
 
 template<typename Table>
 void HeapHashTableBacking<Table>::finalize(void* pointer)
 {
     using Value = typename Table::ValueType;
     ASSERT(!WTF::IsTriviallyDestructible<Value>::value);
@@ skipping 99 matching lines @@
         : Deque<T, inlineCapacity, HeapAllocator>(other)
     {
     }
 };
 
 } // namespace blink
 
 namespace WTF {
 
 template <typename T> struct VectorTraits<blink::Member<T>> : VectorTraitsBase<blink::Member<T>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::WeakMember<T>> : VectorTraitsBase<blink::WeakMember<T>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::UntracedMember<T>> : VectorTraitsBase<blink::UntracedMember<T>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::HeapVector<T, 0>> : VectorTraitsBase<blink::HeapVector<T, 0>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T> struct VectorTraits<blink::HeapDeque<T, 0>> : VectorTraitsBase<blink::HeapDeque<T, 0>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T, size_t inlineCapacity> struct VectorTraits<blink::HeapVector<T, inlineCapacity>> : VectorTraitsBase<blink::HeapVector<T, inlineCapacity>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = VectorTraits<T>::needsDestruction;
     static const bool canInitializeWithMemset = VectorTraits<T>::canInitializeWithMemset;
     static const bool canClearUnusedSlotsWithMemset = VectorTraits<T>::canClearUnusedSlotsWithMemset;
     static const bool canMoveWithMemcpy = VectorTraits<T>::canMoveWithMemcpy;
 };
 
 template <typename T, size_t inlineCapacity> struct VectorTraits<blink::HeapDeque<T, inlineCapacity>> : VectorTraitsBase<blink::HeapDeque<T, inlineCapacity>> {
+    STATIC_ONLY(VectorTraits);
     static const bool needsDestruction = VectorTraits<T>::needsDestruction;
     static const bool canInitializeWithMemset = VectorTraits<T>::canInitializeWithMemset;
     static const bool canClearUnusedSlotsWithMemset = VectorTraits<T>::canClearUnusedSlotsWithMemset;
     static const bool canMoveWithMemcpy = VectorTraits<T>::canMoveWithMemcpy;
 };
 
 template<typename T> struct HashTraits<blink::Member<T>> : SimpleClassHashTraits<blink::Member<T>> {
+    STATIC_ONLY(HashTraits);
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     using PeekInType = RawPtr<T>;
     using PassInType = RawPtr<T>;
     using IteratorGetType = blink::Member<T>*;
     using IteratorConstGetType = const blink::Member<T>*;
     using IteratorReferenceType = blink::Member<T>&;
     using IteratorConstReferenceType = const blink::Member<T>&;
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     using PeekOutType = T*;
     using PassOutType = T*;
 
     template<typename U>
     static void store(const U& value, blink::Member<T>& storage) { storage = value; }
 
     static PeekOutType peek(const blink::Member<T>& value) { return value; }
     static PassOutType passOut(const blink::Member<T>& value) { return value; }
 };
 
 template<typename T> struct HashTraits<blink::WeakMember<T>> : SimpleClassHashTraits<blink::WeakMember<T>> {
+    STATIC_ONLY(HashTraits);
     static const bool needsDestruction = false;
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     using PeekInType = RawPtr<T>;
     using PassInType = RawPtr<T>;
     using IteratorGetType = blink::WeakMember<T>*;
     using IteratorConstGetType = const blink::WeakMember<T>*;
@@ skipping 17 matching lines @@
     {
         if (strongify == WeakPointersActStrong) {
             visitor->trace(weakMember.get()); // Strongified visit.
             return false;
         }
         return !blink::Heap::isHeapObjectAlive(weakMember);
     }
 };
 
 template<typename T> struct HashTraits<blink::UntracedMember<T>> : SimpleClassHashTraits<blink::UntracedMember<T>> {
+    STATIC_ONLY(HashTraits);
     static const bool needsDestruction = false;
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types.
     using PeekInType = RawPtr<T>;
     using PassInType = RawPtr<T>;
     using IteratorGetType = blink::UntracedMember<T>*;
     using IteratorConstGetType = const blink::UntracedMember<T>*;
     using IteratorReferenceType = blink::UntracedMember<T>&;
     using IteratorConstReferenceType = const blink::UntracedMember<T>&;
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     using PeekOutType = T*;
     using PassOutType = T*;
 
     template<typename U>
     static void store(const U& value, blink::UntracedMember<T>& storage) { storage = value; }
 
     static PeekOutType peek(const blink::UntracedMember<T>& value) { return value; }
     static PassOutType passOut(const blink::UntracedMember<T>& value) { return value; }
 };
 
 template<typename T, size_t inlineCapacity>
 struct NeedsTracing<ListHashSetNode<T, blink::HeapListHashSetAllocator<T, inlineCapacity>> *> {
+    STATIC_ONLY(NeedsTracing);
     static_assert(sizeof(T), "T must be fully defined");
     // All heap allocated node pointers need visiting to keep the nodes alive,
     // regardless of whether they contain pointers to other heap allocated
     // objects.
     static const bool value = true;
 };
 
 } // namespace WTF
 
 #endif