Remove ParkThreadsScope

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 39 matching lines @@
 #include "wtf/LeakAnnotations.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/allocator/Partitions.h"
 #include <memory>
 
 namespace blink {
 
 HeapAllocHooks::AllocationHook* HeapAllocHooks::m_allocationHook = nullptr;
 HeapAllocHooks::FreeHook* HeapAllocHooks::m_freeHook = nullptr;
 
-class ParkThreadsScope final {
-  STACK_ALLOCATED();
-
- public:
-  explicit ParkThreadsScope(ThreadState* state)
-      : m_state(state), m_shouldResumeThreads(false) {}
-
-  bool parkThreads() {
-    TRACE_EVENT0("blink_gc", "ThreadHeap::ParkThreadsScope");
-
-    // TODO(haraken): In an unlikely coincidence that two threads decide
-    // to collect garbage at the same time, avoid doing two GCs in
-    // a row and return false.
-    double startTime = WTF::currentTimeMS();
-
-    m_shouldResumeThreads = m_state->heap().park();
-
-    double timeForStoppingThreads = WTF::currentTimeMS() - startTime;
-    DEFINE_THREAD_SAFE_STATIC_LOCAL(
-        CustomCountHistogram, timeToStopThreadsHistogram,
-        new CustomCountHistogram("BlinkGC.TimeForStoppingThreads", 1, 1000,
-                                 50));
-    timeToStopThreadsHistogram.count(timeForStoppingThreads);
-
-    return m_shouldResumeThreads;
-  }
-
-  ~ParkThreadsScope() {
-    // Only cleanup if we parked all threads in which case the GC happened
-    // and we need to resume the other threads.
-    if (m_shouldResumeThreads)
-      m_state->heap().resume();
-  }
-
- private:
-  ThreadState* m_state;
-  bool m_shouldResumeThreads;
-};
-
 void ThreadHeap::flushHeapDoesNotContainCache() {
   m_heapDoesNotContainCache->flush();
 }
 
 void ProcessHeap::init() {
   s_totalAllocatedSpace = 0;
   s_totalAllocatedObjectSize = 0;
   s_totalMarkedObjectSize = 0;
 
   GCInfoTable::init();
@@ skipping 127 matching lines @@
     ASSERT(m_threads.contains(thread));
     m_threads.remove(thread);
     isLastThread = m_threads.isEmpty();
   }
   if (thread->isMainThread())
     DCHECK_EQ(heapStats().allocatedSpace(), 0u);
   if (isLastThread)
     delete this;
 }
 
-bool ThreadHeap::park() {
-  return m_safePointBarrier->parkOthers();
-}
-
-void ThreadHeap::resume() {
-  m_safePointBarrier->resumeOthers();
-}
-
 #if DCHECK_IS_ON()
 BasePage* ThreadHeap::findPageFromAddress(Address address) {
   MutexLocker locker(m_threadAttachMutex);
   for (ThreadState* state : m_threads) {
     if (BasePage* page = state->findPageFromAddress(address))
       return page;
   }
   return nullptr;
 }
 
@@ skipping 382 matching lines @@
   ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
   m_stats.reset();
   for (ThreadState* state : m_threads)
     state->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 }  // namespace blink