Make platform/heap to use USING_FAST_MALLOC.

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

 /*
  * 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 33 matching lines @@
 #include "public/platform/WebProcessMemoryDump.h"
 #include "wtf/Assertions.h"
 #include "wtf/DataLog.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/MainThread.h"
 #include "wtf/Partitions.h"
 
 namespace blink {
 
 class GCForbiddenScope final {
+    DISALLOW_NEW();
 public:
     explicit GCForbiddenScope(ThreadState* state)
         : m_state(state)
     {
         // Prevent nested collectGarbage() invocations.
         m_state->enterGCForbiddenScope();
     }
 
     ~GCForbiddenScope()
     {
         m_state->leaveGCForbiddenScope();
     }
 
 private:
     ThreadState* m_state;
 };
 
 class GCScope final {
+    STACK_ALLOCATED();
 public:
     GCScope(ThreadState* state, BlinkGC::StackState stackState, BlinkGC::GCType gcType)
         : m_state(state)
         , m_gcForbiddenScope(state)
     {
         ASSERT(m_state->checkThread());
 
         switch (gcType) {
         case BlinkGC::GCWithSweep:
         case BlinkGC::GCWithoutSweep:
@@ skipping 38 matching lines @@
     Visitor* visitor() const { return m_visitor.get(); }
 
 private:
     ThreadState* m_state;
     // See ThreadState::runScheduledGC() why we need to already be in a
     // GCForbiddenScope before any safe point is entered.
     GCForbiddenScope m_gcForbiddenScope;
     OwnPtr<Visitor> m_visitor;
 };
 
-class ResumeThreadScope {
+class ResumeThreadScope final {
+    STACK_ALLOCATED();
 public:
     explicit ResumeThreadScope(BlinkGC::GCType gcType)
         : m_resumeThreads(gcType != BlinkGC::ThreadTerminationGC)
     {
     }
     ~ResumeThreadScope()
     {
         // Only cleanup if we parked all threads in which case the GC happened
         // and we need to resume the other threads.
         if (m_resumeThreads)
             ThreadState::resumeThreads();
     }
 private:
     bool m_resumeThreads;
 };
 
 void Heap::flushHeapDoesNotContainCache()
 {
     s_heapDoesNotContainCache->flush();
 }
 
 void Heap::init()
 {
     ThreadState::init();
     s_markingStack = new CallbackStack();
     s_postMarkingCallbackStack = new CallbackStack();
     s_globalWeakCallbackStack = new CallbackStack();
     s_ephemeronStack = new CallbackStack();
-    s_heapDoesNotContainCache = new HeapDoesNotContainCache();
+    s_heapDoesNotContainCache = HeapDoesNotContainCache::create();
     s_freePagePool = new FreePagePool();
     s_orphanedPagePool = new OrphanedPagePool();
     s_allocatedSpace = 0;
     s_allocatedObjectSize = 0;
     s_objectSizeAtLastGC = 0;
     s_markedObjectSize = 0;
     s_markedObjectSizeAtLastCompleteSweep = 0;
     s_wrapperCount = 0;
     s_wrapperCountAtLastGC = 0;
     s_collectedWrapperCount = 0;
@@ skipping 541 matching lines @@
 size_t Heap::s_wrapperCount = 0;
 size_t Heap::s_wrapperCountAtLastGC = 0;
 size_t Heap::s_collectedWrapperCount = 0;
 size_t Heap::s_partitionAllocSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 #if ENABLE(ASSERT)
 uint16_t Heap::s_gcGeneration = 0;
 #endif
 
 } // namespace blink