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

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 63 matching lines @@
     {
         m_state->leaveGCForbiddenScope();
     }
 
 private:
     ThreadState* m_state;
 };
 
 class GCScope final {
 public:
-    GCScope(ThreadState* state, ThreadState::StackState stackState, ThreadState::GCType gcType)
+    GCScope(ThreadState* state, BlinkGC::StackState stackState, BlinkGC::GCType gcType)
         : m_state(state)
         , m_gcForbiddenScope(state)
         // See collectGarbageForTerminatingThread() comment on why a
         // safepoint scope isn't entered for its GCScope.
-        , m_safePointScope(stackState, gcType != ThreadState::ThreadTerminationGC ? state : nullptr)
+        , m_safePointScope(stackState, gcType != BlinkGC::ThreadTerminationGC ? state : nullptr)
         , m_gcType(gcType)
         , m_parkedAllThreads(false)
     {
         TRACE_EVENT0("blink_gc", "Heap::GCScope");
         const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
         if (m_state->isMainThread())
             TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
 
         ASSERT(m_state->checkThread());
 
         // TODO(haraken): In an unlikely coincidence that two threads decide
         // to collect garbage at the same time, avoid doing two GCs in
         // a row.
-        if (LIKELY(gcType != ThreadState::ThreadTerminationGC && ThreadState::stopThreads()))
+        if (LIKELY(gcType != BlinkGC::ThreadTerminationGC && ThreadState::stopThreads()))
             m_parkedAllThreads = true;
 
         switch (gcType) {
-        case ThreadState::GCWithSweep:
-        case ThreadState::GCWithoutSweep:
+        case BlinkGC::GCWithSweep:
+        case BlinkGC::GCWithoutSweep:
             m_visitor = adoptPtr(new MarkingVisitor<Visitor::GlobalMarking>());
             break;
-        case ThreadState::TakeSnapshot:
+        case BlinkGC::TakeSnapshot:
             m_visitor = adoptPtr(new MarkingVisitor<Visitor::SnapshotMarking>());
             break;
-        case ThreadState::ThreadTerminationGC:
+        case BlinkGC::ThreadTerminationGC:
             m_visitor = adoptPtr(new MarkingVisitor<Visitor::ThreadLocalMarking>());
             break;
         default:
             ASSERT_NOT_REACHED();
         }
 
         if (m_state->isMainThread())
             TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
     }
 
     bool allThreadsParked() const { return m_parkedAllThreads; }
     Visitor* visitor() const { return m_visitor.get(); }
 
     ~GCScope()
     {
         // Only cleanup if we parked all threads in which case the GC happened
         // and we need to resume the other threads.
-        if (LIKELY(m_gcType != ThreadState::ThreadTerminationGC && m_parkedAllThreads))
+        if (LIKELY(m_gcType != BlinkGC::ThreadTerminationGC && m_parkedAllThreads))
             ThreadState::resumeThreads();
     }
 
 private:
     ThreadState* m_state;
     // The ordering of the two scope objects matters: GCs must first be forbidden
     // before entering the safe point scope. Prior to reaching the safe point,
     // ThreadState::runScheduledGC() is called. See its comment why we need
     // to be in a GC forbidden scope when doing so.
     GCForbiddenScope m_gcForbiddenScope;
     SafePointScope m_safePointScope;
-    ThreadState::GCType m_gcType;
+    BlinkGC::GCType m_gcType;
     OwnPtr<Visitor> m_visitor;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 void Heap::flushHeapDoesNotContainCache()
 {
     s_heapDoesNotContainCache->flush();
 }
 
 void Heap::init()
@@ skipping 230 matching lines @@
 }
 #endif
 
 void Heap::preGC()
 {
     ASSERT(!ThreadState::current()->isInGC());
     for (ThreadState* state : ThreadState::attachedThreads())
         state->preGC();
 }
 
-void Heap::postGC(ThreadState::GCType gcType)
+void Heap::postGC(BlinkGC::GCType gcType)
 {
     ASSERT(ThreadState::current()->isInGC());
     for (ThreadState* state : ThreadState::attachedThreads())
         state->postGC(gcType);
 }
 
 const char* Heap::gcReasonString(GCReason reason)
 {
     switch (reason) {
 #define STRINGIFY_REASON(reason) case reason: return #reason;
         STRINGIFY_REASON(IdleGC);
         STRINGIFY_REASON(PreciseGC);
         STRINGIFY_REASON(ConservativeGC);
         STRINGIFY_REASON(ForcedGC);
         STRINGIFY_REASON(MemoryPressureGC);
         STRINGIFY_REASON(PageNavigationGC);
 #undef STRINGIFY_REASON
     case NumberOfGCReason: ASSERT_NOT_REACHED();
     }
     return "<Unknown>";
 }
 
-void Heap::collectGarbage(ThreadState::StackState stackState, ThreadState::GCType gcType, GCReason reason)
+void Heap::collectGarbage(BlinkGC::StackState stackState, BlinkGC::GCType gcType, GCReason reason)
 {
     ThreadState* state = ThreadState::current();
     // Nested collectGarbage() invocations aren't supported.
     RELEASE_ASSERT(!state->isGCForbidden());
     state->completeSweep();
 
     GCScope gcScope(state, stackState, gcType);
     // Check if we successfully parked the other threads.  If not we bail out of
     // the GC.
     if (!gcScope.allThreadsParked())
         return;
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     TRACE_EVENT2("blink_gc", "Heap::collectGarbage",
-        "lazySweeping", gcType == ThreadState::GCWithoutSweep,
+        "lazySweeping", gcType == BlinkGC::GCWithoutSweep,
         "gcReason", gcReasonString(reason));
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
 
-    if (gcType == ThreadState::TakeSnapshot)
+    if (gcType == BlinkGC::TakeSnapshot)
         BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
 
     // Disallow allocation during garbage collection (but not during the
     // finalization that happens when the gcScope is torn down).
     ThreadState::NoAllocationScope noAllocationScope(state);
 
     preGC();
 
     StackFrameDepthScope stackDepthScope;
 
     size_t totalObjectSize = Heap::allocatedObjectSize() + Heap::markedObjectSize();
-    if (gcType != ThreadState::TakeSnapshot)
+    if (gcType != BlinkGC::TakeSnapshot)
         Heap::resetHeapCounters();
 
     // 1. Trace persistent roots.
     ThreadState::visitPersistentRoots(gcScope.visitor());
 
     // 2. Trace objects reachable from the stack.  We do this independent of the
     // given stackState since other threads might have a different stack state.
     ThreadState::visitStackRoots(gcScope.visitor());
 
     // 3. Transitive closure to trace objects including ephemerons.
     processMarkingStack(gcScope.visitor());
 
     postMarkingProcessing(gcScope.visitor());
     globalWeakProcessing(gcScope.visitor());
 
     // Now we can delete all orphaned pages because there are no dangling
     // pointers to the orphaned pages.  (If we have such dangling pointers,
     // we should have crashed during marking before getting here.)
     orphanedPagePool()->decommitOrphanedPages();
 
     double markingTimeInMilliseconds = WTF::currentTimeMS() - timeStamp;
     s_estimatedMarkingTimePerByte = totalObjectSize ? (markingTimeInMilliseconds / 1000 / totalObjectSize) : 0;
 
 #if PRINT_HEAP_STATS
-    dataLogF("Heap::collectGarbage (gcReason=%s, lazySweeping=%d, time=%.1lfms)\n", gcReasonString(reason), gcType == ThreadState::GCWithoutSweep, markingTimeInMilliseconds);
+    dataLogF("Heap::collectGarbage (gcReason=%s, lazySweeping=%d, time=%.1lfms)\n", gcReasonString(reason), gcType == BlinkGC::GCWithoutSweep, markingTimeInMilliseconds);
 #endif
 
     Platform::current()->histogramCustomCounts("BlinkGC.CollectGarbage", markingTimeInMilliseconds, 0, 10 * 1000, 50);
     Platform::current()->histogramCustomCounts("BlinkGC.TotalObjectSpace", Heap::allocatedObjectSize() / 1024, 0, 4 * 1024 * 1024, 50);
     Platform::current()->histogramCustomCounts("BlinkGC.TotalAllocatedSpace", Heap::allocatedSpace() / 1024, 0, 4 * 1024 * 1024, 50);
     Platform::current()->histogramEnumeration("BlinkGC.GCReason", reason, NumberOfGCReason);
     Heap::reportMemoryUsageHistogram();
     WTF::Partitions::reportMemoryUsageHistogram();
 
     postGC(gcType);
 
     if (state->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 void Heap::collectGarbageForTerminatingThread(ThreadState* state)
 {
     {
         // A thread-specific termination GC must not allow other global GCs to go
         // ahead while it is running, hence the termination GC does not enter a
         // safepoint. GCScope will not enter also a safepoint scope for
         // ThreadTerminationGC.
-        GCScope gcScope(state, ThreadState::NoHeapPointersOnStack, ThreadState::ThreadTerminationGC);
+        GCScope gcScope(state, BlinkGC::NoHeapPointersOnStack, BlinkGC::ThreadTerminationGC);
 
         ThreadState::NoAllocationScope noAllocationScope(state);
 
         state->preGC();
         StackFrameDepthScope stackDepthScope;
 
         // 1. Trace the thread local persistent roots. For thread local GCs we
         // don't trace the stack (ie. no conservative scanning) since this is
         // only called during thread shutdown where there should be no objects
         // on the stack.
         // We also assume that orphaned pages have no objects reachable from
         // persistent handles on other threads or CrossThreadPersistents.  The
         // only cases where this could happen is if a subsequent conservative
         // global GC finds a "pointer" on the stack or due to a programming
         // error where an object has a dangling cross-thread pointer to an
         // object on this heap.
         state->visitPersistents(gcScope.visitor());
 
         // 2. Trace objects reachable from the thread's persistent roots
         // including ephemerons.
         processMarkingStack(gcScope.visitor());
 
         postMarkingProcessing(gcScope.visitor());
         globalWeakProcessing(gcScope.visitor());
 
-        state->postGC(ThreadState::GCWithSweep);
+        state->postGC(BlinkGC::GCWithSweep);
     }
     state->preSweep();
 }
 
 void Heap::processMarkingStack(Visitor* visitor)
 {
     // Ephemeron fixed point loop.
     do {
         {
             // Iteratively mark all objects that are reachable from the objects
@@ skipping 40 matching lines @@
     // It is not permitted to trace pointers of live objects in the weak
     // callback phase, so the marking stack should still be empty here.
     ASSERT(s_markingStack->isEmpty());
 }
 
 void Heap::collectAllGarbage()
 {
     // We need to run multiple GCs to collect a chain of persistent handles.
     size_t previousLiveObjects = 0;
     for (int i = 0; i < 5; ++i) {
-        collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, ForcedGC);
+        collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, ForcedGC);
         size_t liveObjects = Heap::markedObjectSize();
         if (liveObjects == previousLiveObjects)
             break;
         previousLiveObjects = liveObjects;
     }
 }
 
 double Heap::estimatedMarkingTime()
 {
     ASSERT(ThreadState::current()->isMainThread());
@@ skipping 188 matching lines @@
 size_t Heap::s_objectSizeAtLastGC = 0;
 size_t Heap::s_markedObjectSize = 0;
 size_t Heap::s_markedObjectSizeAtLastCompleteSweep = 0;
 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;
 
 } // namespace blink