Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #ifndef Heap_h
 #define Heap_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/HeapPage.h"
 #include "platform/heap/PageMemory.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/AddressSanitizer.h"
+#include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
 #include "wtf/Forward.h"
 
 namespace blink {
 
 class CrossThreadPersistentRegion;
 template<typename T> class Member;
 template<typename T> class WeakMember;
 template<typename T> class UntracedMember;
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class ObjectAliveTrait;
 
 template<typename T>
 class ObjectAliveTrait<T, false> {
+    STATIC_ONLY(ObjectAliveTrait);
 public:
     static bool isHeapObjectAlive(T* object)
     {
         static_assert(sizeof(T), "T must be fully defined");
         return HeapObjectHeader::fromPayload(object)->isMarked();
     }
 };
 
 template<typename T>
 class ObjectAliveTrait<T, true> {
+    STATIC_ONLY(ObjectAliveTrait);
 public:
     static bool isHeapObjectAlive(T* object)
     {
         static_assert(sizeof(T), "T must be fully defined");
         return object->isHeapObjectAlive();
     }
 };
 
 class PLATFORM_EXPORT Heap {
+    STATIC_ONLY(Heap);
 public:
     static void init();
     static void shutdown();
     static void doShutdown();
 
     static CrossThreadPersistentRegion& crossThreadPersistentRegion();
 
 #if ENABLE(ASSERT)
     static BasePage* findPageFromAddress(Address);
     static BasePage* findPageFromAddress(const void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(const_cast<void*>(pointer))); }
@@ skipping 210 matching lines @@
     static double s_estimatedMarkingTimePerByte;
 #if ENABLE(ASSERT)
     static uint16_t s_gcGeneration;
 #endif
 
     friend class ThreadState;
 };
 
 template<typename T>
 struct IsEagerlyFinalizedType {
+    STATIC_ONLY(IsEagerlyFinalizedType);
 private:
     typedef char YesType;
     struct NoType {
         char padding[8];
     };
 
     template <typename U> static YesType checkMarker(typename U::IsEagerlyFinalizedMarker*);
     template <typename U> static NoType checkMarker(...);
 
 public:
@@ skipping 84 matching lines @@
 public:                                           \
     GC_PLUGIN_IGNORE("491488")                    \
     void* operator new(size_t size)               \
     {                                             \
         return allocateObject(size, true);        \
     }
 
 #define IS_EAGERLY_FINALIZED() (pageFromObject(this)->heap()->heapIndex() == BlinkGC::EagerSweepHeapIndex)
 #if ENABLE(ASSERT) && ENABLE(OILPAN)
 class VerifyEagerFinalization {
+    DISALLOW_NEW();
 public:
     ~VerifyEagerFinalization()
     {
         // If this assert triggers, the class annotated as eagerly
         // finalized ended up not being allocated on the heap
         // set aside for eager finalization. The reason is most
         // likely that the effective 'operator new' overload for
         // this class' leftmost base is for a class that is not
         // eagerly finalized. Declaring and defining an 'operator new'
         // for this class is what's required -- consider using
@@ skipping 69 matching lines @@
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object)
 {
     T** cell = reinterpret_cast<T**>(object);
     if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
 } // namespace blink
 
 #endif // Heap_h