Oilpan: Factor out GC-related enum definitions to BlinkGC.h

third_party/WebKit/Source/platform/heap/ThreadState.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 80 matching lines @@
     : m_thread(currentThread())
     , m_persistentRegion(adoptPtr(new PersistentRegion()))
     , m_startOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_safePointScopeMarker(nullptr)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_sweepForbidden(false)
     , m_noAllocationCount(0)
     , m_gcForbiddenCount(0)
-    , m_vectorBackingHeapIndex(Vector1HeapIndex)
+    , m_vectorBackingHeapIndex(BlinkGC::Vector1HeapIndex)
     , m_currentHeapAges(0)
     , m_isTerminating(false)
     , m_gcMixinMarker(nullptr)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_gcState(NoGCScheduled)
     , m_traceDOMWrappers(nullptr)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
 #if ENABLE(GC_PROFILING)
     , m_nextFreeListSnapshotTime(-std::numeric_limits<double>::infinity())
 #endif
 {
     ASSERT(checkThread());
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     if (isMainThread()) {
         s_mainThreadStackStart = reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         size_t underestimatedStackSize = StackFrameDepth::getUnderestimatedStackSize();
         if (underestimatedStackSize > sizeof(void*))
             s_mainThreadUnderestimatedStackSize = underestimatedStackSize - sizeof(void*);
     }
 
-    for (int heapIndex = 0; heapIndex < LargeObjectHeapIndex; heapIndex++)
+    for (int heapIndex = 0; heapIndex < BlinkGC::LargeObjectHeapIndex; heapIndex++)
         m_heaps[heapIndex] = new NormalPageHeap(this, heapIndex);
-    m_heaps[LargeObjectHeapIndex] = new LargeObjectHeap(this, LargeObjectHeapIndex);
+    m_heaps[BlinkGC::LargeObjectHeapIndex] = new LargeObjectHeap(this, BlinkGC::LargeObjectHeapIndex);
 
     m_likelyToBePromptlyFreed = adoptArrayPtr(new int[likelyToBePromptlyFreedArraySize]);
     clearHeapAges();
 
     m_threadLocalWeakCallbackStack = new CallbackStack();
 }
 
 ThreadState::~ThreadState()
 {
     ASSERT(checkThread());
     delete m_threadLocalWeakCallbackStack;
     m_threadLocalWeakCallbackStack = nullptr;
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         delete m_heaps[i];
 
     **s_threadSpecific = nullptr;
     if (isMainThread()) {
         s_mainThreadStackStart = 0;
         s_mainThreadUnderestimatedStackSize = 0;
     }
 }
 
 void ThreadState::init()
@@ skipping 22 matching lines @@
 {
     // Enter a safe point before trying to acquire threadAttachMutex
     // to avoid dead lock if another thread is preparing for GC, has acquired
     // threadAttachMutex and waiting for other threads to pause or reach a
     // safepoint.
     ThreadState* state = mainThreadState();
 
     // 1. Finish sweeping.
     state->completeSweep();
     {
-        SafePointAwareMutexLocker locker(threadAttachMutex(), NoHeapPointersOnStack);
+        SafePointAwareMutexLocker locker(threadAttachMutex(), BlinkGC::NoHeapPointersOnStack);
 
         // 2. Add the main thread's heap pages to the orphaned pool.
         state->cleanupPages();
 
         // 3. Detach the main thread.
         ASSERT(attachedThreads().contains(state));
         attachedThreads().remove(state);
         state->~ThreadState();
     }
     shutdownHeapIfNecessary();
@@ skipping 15 matching lines @@
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
     MutexLocker locker(threadAttachMutex());
     ThreadState* state = new ThreadState();
     attachedThreads().add(state);
 }
 
 void ThreadState::cleanupPages()
 {
     ASSERT(checkThread());
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->cleanupPages();
 }
 
 void ThreadState::cleanup()
 {
     ASSERT(checkThread());
     {
         // Grab the threadAttachMutex to ensure only one thread can shutdown at
         // a time and that no other thread can do a global GC. It also allows
         // safe iteration of the attachedThreads set which happens as part of
         // thread local GC asserts. We enter a safepoint while waiting for the
         // lock to avoid a dead-lock where another thread has already requested
         // GC.
-        SafePointAwareMutexLocker locker(threadAttachMutex(), NoHeapPointersOnStack);
+        SafePointAwareMutexLocker locker(threadAttachMutex(), BlinkGC::NoHeapPointersOnStack);
 
         // Finish sweeping.
         completeSweep();
 
         // From here on ignore all conservatively discovered
         // pointers into the heap owned by this thread.
         m_isTerminating = true;
 
         // Set the terminate flag on all heap pages of this thread. This is used to
         // ensure we don't trace pages on other threads that are not part of the
@@ skipping 77 matching lines @@
             for (Address* p = fakeFrameStart; p < fakeFrameEnd; ++p)
                 Heap::checkAndMarkPointer(visitor, *p);
         }
     }
 #endif
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
-    if (m_stackState == NoHeapPointersOnStack)
+    if (m_stackState == BlinkGC::NoHeapPointersOnStack)
         return;
 
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
     // If there is a safepoint scope marker we should stop the stack
     // scanning there to not touch active parts of the stack. Anything
     // interesting beyond that point is in the safepoint stack copy.
     // If there is no scope marker the thread is blocked and we should
     // scan all the way to the recorded end stack pointer.
     Address* end = reinterpret_cast<Address*>(m_endOfStack);
     Address* safePointScopeMarker = reinterpret_cast<Address*>(m_safePointScopeMarker);
@@ skipping 68 matching lines @@
 
 void ThreadState::snapshot()
 {
     SnapshotInfo info(this);
     RefPtr<TracedValue> json = TracedValue::create();
 
 #define SNAPSHOT_HEAP(HeapType)                                    \
     {                                                              \
         json->beginDictionary();                                   \
         json->setString("name", #HeapType);                        \
-        m_heaps[HeapType##HeapIndex]->snapshot(json.get(), &info); \
+        m_heaps[BlinkGC::HeapType##HeapIndex]->snapshot(json.get(), &info); \
         json->endDictionary();                                     \
     }
     json->beginArray("heaps");
     SNAPSHOT_HEAP(EagerSweep);
     SNAPSHOT_HEAP(NormalPage1);
     SNAPSHOT_HEAP(NormalPage2);
     SNAPSHOT_HEAP(NormalPage3);
     SNAPSHOT_HEAP(NormalPage4);
     SNAPSHOT_HEAP(Vector1);
     SNAPSHOT_HEAP(Vector2);
@@ skipping 36 matching lines @@
     }
     json->endArray();
     json->setInteger("liveSize", liveSize);
     json->setInteger("deadSize", deadSize);
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("blink_gc", "ThreadState", this, json.release());
 }
 
 void ThreadState::incrementMarkedObjectsAge()
 {
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->incrementMarkedObjectsAge();
 }
 #endif
 
 void ThreadState::pushThreadLocalWeakCallback(void* object, WeakCallback callback)
 {
     CallbackStack::Item* slot = m_threadLocalWeakCallbackStack->allocateEntry();
     *slot = CallbackStack::Item(object, callback);
 }
 
@@ skipping 151 matching lines @@
 
 // If we're consuming too much memory, trigger a conservative GC
 // aggressively. This is a safe guard to avoid OOM.
 bool ThreadState::shouldForceMemoryPressureGC()
 {
     if (totalMemorySize() < 300 * 1024 * 1024)
         return false;
     return judgeGCThreshold(0, 1.5);
 }
 
-void ThreadState::scheduleV8FollowupGCIfNeeded(V8GCType gcType)
+void ThreadState::scheduleV8FollowupGCIfNeeded(BlinkGC::V8GCType gcType)
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
-    dataLogF("ThreadState::scheduleV8FollowupGCIfNeeded (gcType=%s)\n", gcType == V8MajorGC ? "MajorGC" : "MinorGC");
+    dataLogF("ThreadState::scheduleV8FollowupGCIfNeeded (gcType=%s)\n", gcType == BlinkGC::V8MajorGC ? "MajorGC" : "MinorGC");
 #endif
 
     if (isGCForbidden())
         return;
 
     // This completeSweep() will do nothing in common cases since we've
     // called completeSweep() before V8 starts minor/major GCs.
     completeSweep();
     ASSERT(!isSweepingInProgress());
     ASSERT(!sweepForbidden());
 
     // TODO(haraken): Consider if we should trigger a memory pressure GC
     // for V8 minor GCs as well.
-    if (gcType == V8MajorGC && shouldForceMemoryPressureGC()) {
+    if (gcType == BlinkGC::V8MajorGC && shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled MemoryPressureGC\n");
 #endif
-        Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::MemoryPressureGC);
+        Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::MemoryPressureGC);
         return;
     }
     if (shouldScheduleV8FollowupGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled PreciseGC\n");
 #endif
         schedulePreciseGC();
         return;
     }
-    if (gcType == V8MajorGC) {
+    if (gcType == BlinkGC::V8MajorGC) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled IdleGC\n");
 #endif
         scheduleIdleGC();
         return;
     }
 }
 
 void ThreadState::willStartV8GC()
 {
     // Finish Oilpan's complete sweeping before running a V8 GC.
     // This will let the GC collect more V8 objects.
     //
     // TODO(haraken): It's a bit too late for a major GC to schedule
     // completeSweep() here, because gcPrologue for a major GC is called
     // not at the point where the major GC started but at the point where
     // the major GC requests object grouping.
     completeSweep();
 
     // The fact that the PageNavigation GC is scheduled means that there is
     // a dead frame. In common cases, a sequence of Oilpan's GC => V8 GC =>
     // Oilpan's GC is needed to collect the dead frame. So we force the
     // PageNavigation GC before running the V8 GC.
     if (gcState() == PageNavigationGCScheduled) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled PageNavigationGC\n");
 #endif
-        Heap::collectGarbage(HeapPointersOnStack, GCWithSweep, Heap::PageNavigationGC);
+        Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithSweep, Heap::PageNavigationGC);
     }
 }
 
 void ThreadState::schedulePageNavigationGCIfNeeded(float estimatedRemovalRatio)
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
     dataLogF("ThreadState::schedulePageNavigationGCIfNeeded (estimatedRemovalRatio=%.2lf)\n", estimatedRemovalRatio);
 #endif
 
     if (isGCForbidden())
         return;
 
     // Finish on-going lazy sweeping.
     // TODO(haraken): It might not make sense to force completeSweep() for all
     // page navigations.
     completeSweep();
     ASSERT(!isSweepingInProgress());
     ASSERT(!sweepForbidden());
 
     if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled MemoryPressureGC\n");
 #endif
-        Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::MemoryPressureGC);
+        Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::MemoryPressureGC);
         return;
     }
     if (shouldSchedulePageNavigationGC(estimatedRemovalRatio)) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled PageNavigationGC\n");
 #endif
         schedulePageNavigationGC();
         return;
     }
 }
@@ skipping 18 matching lines @@
     // trigger nested GCs.
     if (isGCForbidden())
         return;
 
     if (shouldForceMemoryPressureGC()) {
         completeSweep();
         if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
             dataLogF("Scheduled MemoryPressureGC\n");
 #endif
-            Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::MemoryPressureGC);
+            Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::MemoryPressureGC);
             return;
         }
     }
 
     if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
 
     if (shouldForceConservativeGC()) {
         completeSweep();
         if (shouldForceConservativeGC()) {
 #if PRINT_HEAP_STATS
             dataLogF("Scheduled ConservativeGC\n");
 #endif
-            Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
+            Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::ConservativeGC);
             return;
         }
     }
     if (shouldScheduleIdleGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled IdleGC\n");
 #endif
         scheduleIdleGC();
         return;
     }
 }
 
 void ThreadState::performIdleGC(double deadlineSeconds)
 {
     ASSERT(checkThread());
     ASSERT(isMainThread());
 
     if (gcState() != IdleGCScheduled)
         return;
 
     double idleDeltaInSeconds = deadlineSeconds - Platform::current()->monotonicallyIncreasingTime();
     TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds", idleDeltaInSeconds, "estimatedMarkingTime", Heap::estimatedMarkingTime());
     if (idleDeltaInSeconds <= Heap::estimatedMarkingTime() && !Platform::current()->currentThread()->scheduler()->canExceedIdleDeadlineIfRequired()) {
         // If marking is estimated to take longer than the deadline and we can't
         // exceed the deadline, then reschedule for the next idle period.
         scheduleIdleGC();
         return;
     }
 
-    Heap::collectGarbage(NoHeapPointersOnStack, GCWithoutSweep, Heap::IdleGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::IdleGC);
 }
 
 void ThreadState::performIdleLazySweep(double deadlineSeconds)
 {
     ASSERT(checkThread());
     ASSERT(isMainThread());
 
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
 
     // This check is here to prevent performIdleLazySweep() from being called
     // recursively. I'm not sure if it can happen but it would be safer to have
     // the check just in case.
     if (sweepForbidden())
         return;
 
     TRACE_EVENT1("blink_gc", "ThreadState::performIdleLazySweep", "idleDeltaInSeconds", deadlineSeconds - Platform::current()->monotonicallyIncreasingTime());
 
     bool sweepCompleted = true;
     SweepForbiddenScope scope(this);
     {
         if (isMainThread())
             ScriptForbiddenScope::enter();
 
-        for (int i = 0; i < NumberOfHeaps; i++) {
+        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++) {
             // lazySweepWithDeadline() won't check the deadline until it sweeps
             // 10 pages. So we give a small slack for safety.
             double slack = 0.001;
             double remainingBudget = deadlineSeconds - slack - Platform::current()->monotonicallyIncreasingTime();
             if (remainingBudget <= 0 || !m_heaps[i]->lazySweepWithDeadline(deadlineSeconds)) {
                 // We couldn't finish the sweeping within the deadline.
                 // We request another idle task for the remaining sweeping.
                 scheduleIdleLazySweep();
                 sweepCompleted = false;
                 break;
@@ skipping 110 matching lines @@
     }
     m_gcState = gcState;
 #if ENABLE(GC_PROFILING)
     if (isMainThread())
         TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::gcState", static_cast<int>(m_gcState));
 #endif
 }
 
 #undef VERIFY_STATE_TRANSITION
 
-ThreadState::GCState ThreadState::gcState() const
-{
-    return m_gcState;
-}
-
-void ThreadState::runScheduledGC(StackState stackState)
+void ThreadState::runScheduledGC(BlinkGC::StackState stackState)
 {
     ASSERT(checkThread());
-    if (stackState != NoHeapPointersOnStack)
+    if (stackState != BlinkGC::NoHeapPointersOnStack)
         return;
 
     // If a safe point is entered while initiating a GC, we clearly do
     // not want to do another as part that -- the safe point is only
     // entered after checking if a scheduled GC ought to run first.
     // Prevent that from happening by marking GCs as forbidden while
     // one is initiated and later running.
     if (isGCForbidden())
         return;
 
     switch (gcState()) {
     case FullGCScheduled:
         Heap::collectAllGarbage();
         break;
     case PreciseGCScheduled:
-        Heap::collectGarbage(NoHeapPointersOnStack, GCWithoutSweep, Heap::PreciseGC);
+        Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::PreciseGC);
         break;
     case PageNavigationGCScheduled:
-        Heap::collectGarbage(NoHeapPointersOnStack, GCWithSweep, Heap::PageNavigationGC);
+        Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, Heap::PageNavigationGC);
         break;
     case IdleGCScheduled:
         // Idle time GC will be scheduled by Blink Scheduler.
         break;
     default:
         break;
     }
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
 {
     if (m_shouldFlushHeapDoesNotContainCache) {
         Heap::flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
 void ThreadState::makeConsistentForGC()
 {
     ASSERT(isInGC());
     TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForGC");
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->makeConsistentForGC();
 }
 
 void ThreadState::makeConsistentForMutator()
 {
     ASSERT(isInGC());
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC()
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
     makeConsistentForGC();
     flushHeapDoesNotContainCacheIfNeeded();
     clearHeapAges();
 }
 
-void ThreadState::postGC(GCType gcType)
+void ThreadState::postGC(BlinkGC::GCType gcType)
 {
     ASSERT(isInGC());
 
 #if ENABLE(GC_PROFILING)
     // We snapshot the heap prior to sweeping to get numbers for both resources
     // that have been allocated since the last GC and for resources that are
     // going to be freed.
     bool gcTracingEnabled;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink_gc", &gcTracingEnabled);
 
     if (gcTracingEnabled) {
         bool disabledByDefaultGCTracingEnabled;
         TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink_gc"), &disabledByDefaultGCTracingEnabled);
 
         snapshot();
         if (disabledByDefaultGCTracingEnabled)
             collectAndReportMarkSweepStats();
         incrementMarkedObjectsAge();
     }
 #endif
 
-    for (int i = 0; i < NumberOfHeaps; i++)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
         m_heaps[i]->prepareForSweep();
 
-    if (gcType == GCWithSweep) {
+    if (gcType == BlinkGC::GCWithSweep) {
         setGCState(EagerSweepScheduled);
-    } else if (gcType == GCWithoutSweep) {
+    } else if (gcType == BlinkGC::GCWithoutSweep) {
         setGCState(LazySweepScheduled);
     } else {
         takeSnapshot(SnapshotType::HeapSnapshot);
 
         // This unmarks all marked objects and marks all unmarked objects dead.
         makeConsistentForMutator();
 
         takeSnapshot(SnapshotType::FreelistSnapshot);
 
         // Force setting NoGCScheduled to circumvent checkThread()
@@ skipping 14 matching lines @@
     // We have to set the GCState to Sweeping before calling pre-finalizers
     // to disallow a GC during the pre-finalizers.
     setGCState(Sweeping);
 
     // Allocation is allowed during the pre-finalizers and destructors.
     // However, they must not mutate an object graph in a way in which
     // a dead object gets resurrected.
     invokePreFinalizers();
 
 #if defined(ADDRESS_SANITIZER)
-    poisonEagerHeap(SetPoison);
+    poisonEagerHeap(BlinkGC::SetPoison);
 #endif
 
     eagerSweep();
 #if defined(ADDRESS_SANITIZER)
     poisonAllHeaps();
 #endif
     if (previousGCState == EagerSweepScheduled) {
         // Eager sweeping should happen only in testing.
         completeSweep();
     } else {
         // The default behavior is lazy sweeping.
         scheduleIdleLazySweep();
     }
 
 #if ENABLE(GC_PROFILING)
     snapshotFreeListIfNecessary();
 #endif
 }
 
 #if defined(ADDRESS_SANITIZER)
 void ThreadState::poisonAllHeaps()
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
     // Unpoison the live objects remaining in the eager heaps..
-    poisonEagerHeap(ClearPoison);
+    poisonEagerHeap(BlinkGC::ClearPoison);
     // ..along with poisoning all unmarked objects in the other heaps.
-    for (int i = 1; i < NumberOfHeaps; i++)
-        m_heaps[i]->poisonHeap(UnmarkedOnly, SetPoison);
+    for (int i = 1; i < BlinkGC::NumberOfHeaps; i++)
+        m_heaps[i]->poisonHeap(BlinkGC::UnmarkedOnly, BlinkGC::SetPoison);
 #endif
 }
 
-void ThreadState::poisonEagerHeap(Poisoning poisoning)
+void ThreadState::poisonEagerHeap(BlinkGC::Poisoning poisoning)
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
-    m_heaps[EagerSweepHeapIndex]->poisonHeap(MarkedAndUnmarked, poisoning);
+    m_heaps[BlinkGC::EagerSweepHeapIndex]->poisonHeap(BlinkGC::MarkedAndUnmarked, poisoning);
 #endif
 }
 #endif
 
 void ThreadState::eagerSweep()
 {
     ASSERT(checkThread());
     // Some objects need to be finalized promptly and cannot be handled
     // by lazy sweeping. Keep those in a designated heap and sweep it
     // eagerly.
     ASSERT(isSweepingInProgress());
 
     // Mirroring the completeSweep() condition; see its comment.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     {
         if (isMainThread())
             ScriptForbiddenScope::enter();
 
-        m_heaps[EagerSweepHeapIndex]->completeSweep();
+        m_heaps[BlinkGC::EagerSweepHeapIndex]->completeSweep();
 
         if (isMainThread())
             ScriptForbiddenScope::exit();
     }
 }
 
 void ThreadState::completeSweep()
 {
     ASSERT(checkThread());
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
 
     // completeSweep() can be called recursively if finalizers can allocate
     // memory and the allocation triggers completeSweep(). This check prevents
     // the sweeping from being executed recursively.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     {
         if (isMainThread())
             ScriptForbiddenScope::enter();
 
         TRACE_EVENT0("blink_gc", "ThreadState::completeSweep");
         double timeStamp = WTF::currentTimeMS();
 
-        static_assert(EagerSweepHeapIndex == 0, "Eagerly swept heaps must be processed first.");
-        for (int i = 0; i < NumberOfHeaps; i++)
+        static_assert(BlinkGC::EagerSweepHeapIndex == 0, "Eagerly swept heaps must be processed first.");
+        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
             m_heaps[i]->completeSweep();
 
         Platform::current()->histogramCustomCounts("BlinkGC.CompleteSweep", WTF::currentTimeMS() - timeStamp, 0, 10 * 1000, 50);
 
         if (isMainThread())
             ScriptForbiddenScope::exit();
     }
 
     postSweep();
 }
@@ skipping 30 matching lines @@
         scheduleIdleGC();
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void ThreadState::prepareForThreadStateTermination()
 {
     ASSERT(checkThread());
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->prepareHeapForTermination();
 }
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
 BasePage* ThreadState::findPageFromAddress(Address address)
 {
-    for (int i = 0; i < NumberOfHeaps; ++i) {
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i) {
         if (BasePage* page = m_heaps[i]->findPageFromAddress(address))
             return page;
     }
     return nullptr;
 }
 #endif
 
 size_t ThreadState::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         objectPayloadSize += m_heaps[i]->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
 bool ThreadState::stopThreads()
 {
     return s_safePointBarrier->parkOthers();
 }
 
 void ThreadState::resumeThreads()
 {
     s_safePointBarrier->resumeOthers();
 }
 
-void ThreadState::safePoint(StackState stackState)
+void ThreadState::safePoint(BlinkGC::StackState stackState)
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
     runScheduledGC(stackState);
     ASSERT(!m_atSafePoint);
     m_stackState = stackState;
     m_atSafePoint = true;
     s_safePointBarrier->checkAndPark(this);
     m_atSafePoint = false;
-    m_stackState = HeapPointersOnStack;
+    m_stackState = BlinkGC::HeapPointersOnStack;
     preSweep();
 }
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with detect_stack_use_after_return=1
 // then stack marker obtained from SafePointScope will point into a fake stack.
 // Detect this case by checking if it falls in between current stack frame
 // and stack start and use an arbitrary high enough value for it.
 // Don't adjust stack marker in any other case to match behavior of code running
 // without AddressSanitizer.
 NO_SANITIZE_ADDRESS static void* adjustScopeMarkerForAdressSanitizer(void* scopeMarker)
 {
     Address start = reinterpret_cast<Address>(StackFrameDepth::getStackStart());
     Address end = reinterpret_cast<Address>(&start);
     RELEASE_ASSERT(end < start);
 
     if (end <= scopeMarker && scopeMarker < start)
         return scopeMarker;
 
     // 256 is as good an approximation as any else.
     const size_t bytesToCopy = sizeof(Address) * 256;
     if (static_cast<size_t>(start - end) < bytesToCopy)
         return start;
 
     return end + bytesToCopy;
 }
 #endif
 
-void ThreadState::enterSafePoint(StackState stackState, void* scopeMarker)
+void ThreadState::enterSafePoint(BlinkGC::StackState stackState, void* scopeMarker)
 {
     ASSERT(checkThread());
 #ifdef ADDRESS_SANITIZER
-    if (stackState == HeapPointersOnStack)
+    if (stackState == BlinkGC::HeapPointersOnStack)
         scopeMarker = adjustScopeMarkerForAdressSanitizer(scopeMarker);
 #endif
-    ASSERT(stackState == NoHeapPointersOnStack || scopeMarker);
+    ASSERT(stackState == BlinkGC::NoHeapPointersOnStack || scopeMarker);
     runScheduledGC(stackState);
     ASSERT(!m_atSafePoint);
     m_atSafePoint = true;
     m_stackState = stackState;
     m_safePointScopeMarker = scopeMarker;
     s_safePointBarrier->enterSafePoint(this);
 }
 
 void ThreadState::leaveSafePoint(SafePointAwareMutexLocker* locker)
 {
     ASSERT(checkThread());
     ASSERT(m_atSafePoint);
     s_safePointBarrier->leaveSafePoint(this, locker);
     m_atSafePoint = false;
-    m_stackState = HeapPointersOnStack;
+    m_stackState = BlinkGC::HeapPointersOnStack;
     clearSafePointScopeMarker();
     preSweep();
 }
 
 void ThreadState::copyStackUntilSafePointScope()
 {
-    if (!m_safePointScopeMarker || m_stackState == NoHeapPointersOnStack)
+    if (!m_safePointScopeMarker || m_stackState == BlinkGC::NoHeapPointersOnStack)
         return;
 
     Address* to = reinterpret_cast<Address*>(m_safePointScopeMarker);
     Address* from = reinterpret_cast<Address*>(m_endOfStack);
     RELEASE_ASSERT(from < to);
     RELEASE_ASSERT(to <= reinterpret_cast<Address*>(m_startOfStack));
     size_t slotCount = static_cast<size_t>(to - from);
     // Catch potential performance issues.
 #if defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     // ASan/LSan use more space on the stack and we therefore
     // increase the allowed stack copying for those builds.
     ASSERT(slotCount < 2048);
 #else
     ASSERT(slotCount < 1024);
 #endif
 
     ASSERT(!m_safePointStackCopy.size());
     m_safePointStackCopy.resize(slotCount);
     for (size_t i = 0; i < slotCount; ++i) {
         m_safePointStackCopy[i] = from[i];
     }
 }
 
 void ThreadState::addInterruptor(PassOwnPtr<Interruptor> interruptor)
 {
     ASSERT(checkThread());
-    SafePointScope scope(HeapPointersOnStack);
+    SafePointScope scope(BlinkGC::HeapPointersOnStack);
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
 }
 
 void ThreadState::removeInterruptor(Interruptor* interruptor)
 {
     ASSERT(checkThread());
-    SafePointScope scope(HeapPointersOnStack);
+    SafePointScope scope(BlinkGC::HeapPointersOnStack);
     {
         MutexLocker locker(threadAttachMutex());
         size_t index = m_interruptors.find(interruptor);
         RELEASE_ASSERT(index != kNotFound);
         m_interruptors.remove(index);
     }
 }
 
 void ThreadState::Interruptor::onInterrupted()
 {
     ThreadState* state = ThreadState::current();
     ASSERT(state);
     ASSERT(!state->isAtSafePoint());
-    state->safePoint(HeapPointersOnStack);
+    state->safePoint(BlinkGC::HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 void ThreadState::lockThreadAttachMutex()
 {
@@ skipping 25 matching lines @@
     }
     // FIXME: removeAll is inefficient.  It can shrink repeatedly.
     m_orderedPreFinalizers.removeAll(deadPreFinalizers);
 
     if (isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 void ThreadState::clearHeapAges()
 {
-    memset(m_heapAges, 0, sizeof(size_t) * NumberOfHeaps);
+    memset(m_heapAges, 0, sizeof(size_t) * BlinkGC::NumberOfHeaps);
     memset(m_likelyToBePromptlyFreed.get(), 0, sizeof(int) * likelyToBePromptlyFreedArraySize);
     m_currentHeapAges = 0;
 }
 
 int ThreadState::heapIndexOfVectorHeapLeastRecentlyExpanded(int beginHeapIndex, int endHeapIndex)
 {
     size_t minHeapAge = m_heapAges[beginHeapIndex];
     int heapIndexWithMinHeapAge = beginHeapIndex;
     for (int heapIndex = beginHeapIndex + 1; heapIndex <= endHeapIndex; heapIndex++) {
         if (m_heapAges[heapIndex] < minHeapAge) {
             minHeapAge = m_heapAges[heapIndex];
             heapIndexWithMinHeapAge = heapIndex;
         }
     }
     ASSERT(isVectorHeapIndex(heapIndexWithMinHeapAge));
     return heapIndexWithMinHeapAge;
 }
 
 BaseHeap* ThreadState::expandedVectorBackingHeap(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     --m_likelyToBePromptlyFreed[entryIndex];
     int heapIndex = m_vectorBackingHeapIndex;
     m_heapAges[heapIndex] = ++m_currentHeapAges;
-    m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(Vector1HeapIndex, Vector4HeapIndex);
+    m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
     return m_heaps[heapIndex];
 }
 
 void ThreadState::allocationPointAdjusted(int heapIndex)
 {
     m_heapAges[heapIndex] = ++m_currentHeapAges;
     if (m_vectorBackingHeapIndex == heapIndex)
-        m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(Vector1HeapIndex, Vector4HeapIndex);
+        m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     // See the comment in vectorBackingHeap() for why this is +3.
     m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
 void ThreadState::takeSnapshot(SnapshotType type)
 {
     ASSERT(isInGC());
 
     // 0 is used as index for freelist entries. Objects are indexed 1 to
     // gcInfoIndex.
     GCSnapshotInfo info(GCInfoTable::gcInfoIndex() + 1);
     String threadDumpName = String::format("blink_gc/thread_%lu", static_cast<unsigned long>(m_thread));
     const String heapsDumpName = threadDumpName + "/heaps";
     const String classesDumpName = threadDumpName + "/classes";
 
     int numberOfHeapsReported = 0;
 #define SNAPSHOT_HEAP(HeapType)                                                                \
     {                                                                                          \
         numberOfHeapsReported++;                                                               \
         switch (type) {                                                                        \
         case SnapshotType::HeapSnapshot:                                                       \
-            m_heaps[HeapType##HeapIndex]->takeSnapshot(heapsDumpName + "/" #HeapType, info);   \
+            m_heaps[BlinkGC::HeapType##HeapIndex]->takeSnapshot(heapsDumpName + "/" #HeapType, info);   \
             break;                                                                             \
         case SnapshotType::FreelistSnapshot:                                                   \
-            m_heaps[HeapType##HeapIndex]->takeFreelistSnapshot(heapsDumpName + "/" #HeapType); \
+            m_heaps[BlinkGC::HeapType##HeapIndex]->takeFreelistSnapshot(heapsDumpName + "/" #HeapType); \
             break;                                                                             \
         default:                                                                               \
             ASSERT_NOT_REACHED();                                                              \
         }                                                                                      \
     }
 
     SNAPSHOT_HEAP(NormalPage1);
     SNAPSHOT_HEAP(NormalPage2);
     SNAPSHOT_HEAP(NormalPage3);
     SNAPSHOT_HEAP(NormalPage4);
     SNAPSHOT_HEAP(EagerSweep);
     SNAPSHOT_HEAP(Vector1);
     SNAPSHOT_HEAP(Vector2);
     SNAPSHOT_HEAP(Vector3);
     SNAPSHOT_HEAP(Vector4);
     SNAPSHOT_HEAP(InlineVector);
     SNAPSHOT_HEAP(HashTable);
     SNAPSHOT_HEAP(LargeObject);
     FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
 
-    ASSERT(numberOfHeapsReported == NumberOfHeaps);
+    ASSERT(numberOfHeapsReported == BlinkGC::NumberOfHeaps);
 
 #undef SNAPSHOT_HEAP
 
     if (type == SnapshotType::FreelistSnapshot)
         return;
 
     size_t totalLiveCount = 0;
     size_t totalDeadCount = 0;
     size_t totalLiveSize = 0;
     size_t totalDeadSize = 0;
@@ skipping 60 matching lines @@
 }
 
 void ThreadState::snapshotFreeList()
 {
     RefPtr<TracedValue> json = TracedValue::create();
 
 #define SNAPSHOT_FREE_LIST(HeapType)                           \
     {                                                          \
         json->beginDictionary();                               \
         json->setString("name", #HeapType);                    \
-        m_heaps[HeapType##HeapIndex]->snapshotFreeList(*json); \
+        m_heaps[BlinkGC::HeapType##HeapIndex]->snapshotFreeList(*json); \
         json->endDictionary();                                 \
     }
 
     json->beginArray("heaps");
     SNAPSHOT_FREE_LIST(EagerSweep);
     SNAPSHOT_FREE_LIST(NormalPage1);
     SNAPSHOT_FREE_LIST(NormalPage2);
     SNAPSHOT_FREE_LIST(NormalPage3);
     SNAPSHOT_FREE_LIST(NormalPage4);
     SNAPSHOT_FREE_LIST(Vector1);
@@ skipping 10 matching lines @@
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "FreeList", this, json.release());
 }
 
 void ThreadState::collectAndReportMarkSweepStats() const
 {
     if (!isMainThread())
         return;
 
     ClassAgeCountsMap markingClassAgeCounts;
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->countMarkedObjects(markingClassAgeCounts);
     reportMarkSweepStats("MarkingStats", markingClassAgeCounts);
 
     ClassAgeCountsMap sweepingClassAgeCounts;
-    for (int i = 0; i < NumberOfHeaps; ++i)
+    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
         m_heaps[i]->countObjectsToSweep(sweepingClassAgeCounts);
     reportMarkSweepStats("SweepingStats", sweepingClassAgeCounts);
 }
 
 void ThreadState::reportMarkSweepStats(const char* statsName, const ClassAgeCountsMap& classAgeCounts) const
 {
     RefPtr<TracedValue> json = TracedValue::create();
     for (ClassAgeCountsMap::const_iterator it = classAgeCounts.begin(), end = classAgeCounts.end(); it != end; ++it) {
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink