Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/SafePoint.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 SafePoint_h
 #define SafePoint_h
 
 #include "platform/heap/ThreadState.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 
 class SafePointScope final {
+    STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(SafePointScope);
 public:
     explicit SafePointScope(BlinkGC::StackState stackState, ThreadState* state = ThreadState::current())
         : m_state(state)
     {
         if (m_state) {
             RELEASE_ASSERT(!m_state->isAtSafePoint());
             m_state->enterSafePoint(stackState, this);
         }
     }
 
     ~SafePointScope()
     {
         if (m_state)
             m_state->leaveSafePoint();
     }
 
 private:
     ThreadState* m_state;
 };
 
 // The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
 // a mutex lock. It also ensures that the lock is not held while waiting for a GC
 // to complete in the leaveSafePoint method, by releasing the lock if the
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker final {
+    STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
 public:
     explicit SafePointAwareMutexLocker(MutexBase& mutex, BlinkGC::StackState stackState = BlinkGC::HeapPointersOnStack)
         : m_mutex(mutex)
         , m_locked(false)
     {
         ThreadState* state = ThreadState::current();
         do {
             bool leaveSafePoint = false;
             // We cannot enter a safepoint if we are currently sweeping. In that
@@ skipping 30 matching lines @@
         ASSERT(m_locked);
         m_mutex.unlock();
         m_locked = false;
     }
 
     MutexBase& m_mutex;
     bool m_locked;
 };
 
 class SafePointBarrier final {
+    USING_FAST_MALLOC(SafePointBarrier);
     WTF_MAKE_NONCOPYABLE(SafePointBarrier);
 public:
     SafePointBarrier();
     ~SafePointBarrier();
 
     // Request other attached threads that are not at safe points to park
     // themselves on safepoints.
     bool parkOthers();
 
     // Resume executions of other attached threads that are parked at
@@ skipping 22 matching lines @@
     volatile int m_canResume;
     volatile int m_unparkedThreadCount;
     Mutex m_mutex;
     ThreadCondition m_parked;
     ThreadCondition m_resume;
 };
 
 } // namespace blink
 
 #endif