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

third_party/WebKit/Source/platform/heap/HeapTest.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 32 matching lines @@
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
 
 #include <gtest/gtest.h>
 
 namespace blink {
 
 static void preciselyCollectGarbage()
 {
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, Heap::ForcedGC);
 }
 
 static void conservativelyCollectGarbage()
 {
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithSweep, Heap::ForcedGC);
 }
 
 class IntWrapper : public GarbageCollectedFinalized<IntWrapper> {
 public:
     static IntWrapper* create(int x)
     {
         return new IntWrapper(x);
     }
 
     virtual ~IntWrapper()
@@ skipping 166 matching lines @@
     static void constructDeletedValue(blink::PairWithWeakHandling& slot, bool) { new (NotNull, &slot) blink::PairWithWeakHandling(HashTableDeletedValue); }
     static bool isDeletedValue(const blink::PairWithWeakHandling& value) { return value.isHashTableDeletedValue(); }
 };
 
 }
 
 namespace blink {
 
 class TestGCScope {
 public:
-    explicit TestGCScope(ThreadState::StackState state)
+    explicit TestGCScope(BlinkGC::StackState state)
         : m_state(ThreadState::current())
         , m_safePointScope(state)
         , m_parkedAllThreads(false)
     {
         ASSERT(m_state->checkThread());
         if (LIKELY(ThreadState::stopThreads())) {
             Heap::preGC();
             m_parkedAllThreads = true;
         }
     }
 
     bool allThreadsParked() { return m_parkedAllThreads; }
 
     ~TestGCScope()
     {
         // Only cleanup if we parked all threads in which case the GC happened
         // and we need to resume the other threads.
         if (LIKELY(m_parkedAllThreads)) {
-            Heap::postGC(ThreadState::GCWithSweep);
+            Heap::postGC(BlinkGC::GCWithSweep);
             ThreadState::resumeThreads();
         }
     }
 
 private:
     ThreadState* m_state;
     SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
@@ skipping 186 matching lines @@
 class ThreadedTesterBase {
 protected:
     static void test(ThreadedTesterBase* tester)
     {
         Vector<OwnPtr<WebThread>, numberOfThreads> m_threads;
         for (int i = 0; i < numberOfThreads; i++) {
             m_threads.append(adoptPtr(Platform::current()->createThread("blink gc testing thread")));
             m_threads.last()->taskRunner()->postTask(FROM_HERE, new Task(threadSafeBind(threadFunc, AllowCrossThreadAccess(tester))));
         }
         while (tester->m_threadsToFinish) {
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
         delete tester;
     }
 
     virtual void runThread() = 0;
 
 protected:
     static const int numberOfThreads = 10;
     static const int gcPerThread = 5;
@@ skipping 35 matching lines @@
     }
 
     void runThread() override
     {
         OwnPtr<GlobalIntWrapperPersistent> longLivingPersistent;
         ThreadState::attach();
 
         longLivingPersistent = createGlobalPersistent(0x2a2a2a2a);
         int gcCount = 0;
         while (!done()) {
-            ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
+            ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 OwnPtr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     wrapper = IntWrapper::create(0x0bbac0de);
                     if (!(i % 10)) {
                         globalPersistent = createGlobalPersistent(0x0ed0cabb);
                     }
-                    SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+                    SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
                     preciselyCollectGarbage();
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
 
                 // Taking snapshot shouldn't have any bad side effect.
                 // TODO(haraken): This snapshot GC causes crashes, so disable
                 // it at the moment. Fix the crash and enable it.
-                // Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::TakeSnapshot, Heap::ForcedGC);
+                // Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, Heap::ForcedGC);
                 preciselyCollectGarbage();
                 EXPECT_EQ(wrapper->value(), 0x0bbac0de);
                 EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
             }
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
 
         // Intentionally leak the cross-thread persistent so as to verify
         // that later GCs correctly handle cross-thread persistents that
         // refer to finalized objects after their heaps have been detached
         // and freed.
         EXPECT_TRUE(longLivingPersistent.leakPtr());
 
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
     void runThread() override
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
-            ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
+            ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>> weakMap = new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
                 PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     weakMap->add(static_cast<unsigned>(i), IntWrapper::create(0));
                     weakMap2.add(static_cast<unsigned>(i), IntWrapper::create(0));
-                    SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+                    SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
                     preciselyCollectGarbage();
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
 
                 // Taking snapshot shouldn't have any bad side effect.
                 // TODO(haraken): This snapshot GC causes crashes, so disable
                 // it at the moment. Fix the crash and enable it.
-                // Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::TakeSnapshot, Heap::ForcedGC);
+                // Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, Heap::ForcedGC);
                 preciselyCollectGarbage();
                 EXPECT_TRUE(weakMap->isEmpty());
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadPersistentHeapTester : public ThreadedTesterBase {
 public:
     static void test()
@@ skipping 150 matching lines @@
     // so as to avoid possible warnings about linker duplicates.
     // Override operator new to allocate IntNode subtype objects onto
     // the dedicated heap for blink::Node.
     //
     // TODO(haraken): untangling the heap unit tests from Blink would
     // simplify and avoid running into this problem - http://crbug.com/425381
     GC_PLUGIN_IGNORE("crbug.com/443854")
     void* operator new(size_t size)
     {
         ThreadState* state = ThreadState::current();
-        return Heap::allocateOnHeapIndex(state, size, ThreadState::NodeHeapIndex, GCInfoTrait<IntNode>::index());
+        return Heap::allocateOnHeapIndex(state, size, BlinkGC::NodeHeapIndex, GCInfoTrait<IntNode>::index());
     }
 
     static IntNode* create(int i)
     {
         return new IntNode(i);
     }
 
     DEFINE_INLINE_TRACE() { }
 
     int value() { return m_value; }
@@ skipping 1171 matching lines @@
 #endif
 
 TEST(HeapTest, LazySweepingPages)
 {
     clearOutOldGarbage();
 
     SimpleFinalizedObject::s_destructorCalls = 0;
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     for (int i = 0; i < 1000; i++)
         SimpleFinalizedObject::create();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     for (int i = 0; i < 10000; i++)
         SimpleFinalizedObject::create();
     EXPECT_EQ(1000, SimpleFinalizedObject::s_destructorCalls);
     preciselyCollectGarbage();
     EXPECT_EQ(11000, SimpleFinalizedObject::s_destructorCalls);
 }
 
 TEST(HeapTest, LazySweepingLargeObjectPages)
 {
     clearOutOldGarbage();
 
     // Create free lists that can be reused for IntWrappers created in
     // LargeHeapObject::create().
     Persistent<IntWrapper> p1 = new IntWrapper(1);
     for (int i = 0; i < 100; i++) {
         new IntWrapper(i);
     }
     Persistent<IntWrapper> p2 = new IntWrapper(2);
     preciselyCollectGarbage();
     preciselyCollectGarbage();
 
     LargeHeapObject::s_destructorCalls = 0;
     EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
     for (int i = 0; i < 10; i++)
         LargeHeapObject::create();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
     for (int i = 0; i < 10; i++) {
         LargeHeapObject::create();
         EXPECT_EQ(i + 1, LargeHeapObject::s_destructorCalls);
     }
     LargeHeapObject::create();
     LargeHeapObject::create();
     EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
     preciselyCollectGarbage();
     EXPECT_EQ(22, LargeHeapObject::s_destructorCalls);
 }
 
 class SimpleFinalizedEagerObjectBase : public GarbageCollectedFinalized<SimpleFinalizedEagerObjectBase> {
 public:
     virtual ~SimpleFinalizedEagerObjectBase() { }
     DEFINE_INLINE_TRACE() { }
 
@@ skipping 54 matching lines @@
     SimpleFinalizedEagerObject::s_destructorCalls = 0;
     SimpleFinalizedObjectInstanceOfTemplate::s_destructorCalls = 0;
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     EXPECT_EQ(0, SimpleFinalizedEagerObject::s_destructorCalls);
     for (int i = 0; i < 1000; i++)
         SimpleFinalizedObject::create();
     for (int i = 0; i < 100; i++)
         SimpleFinalizedEagerObject::create();
     for (int i = 0; i < 100; i++)
         SimpleFinalizedObjectInstanceOfTemplate::create();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     EXPECT_EQ(100, SimpleFinalizedEagerObject::s_destructorCalls);
     EXPECT_EQ(100, SimpleFinalizedObjectInstanceOfTemplate::s_destructorCalls);
 }
 
 TEST(HeapTest, Finalization)
 {
     {
         HeapTestSubClass* t1 = HeapTestSubClass::create();
         HeapTestSubClass* t2 = HeapTestSubClass::create();
@@ skipping 1696 matching lines @@
     largeObjectEndAddress = largeObjectAddress + sizeof(LargeHeapObject) - 1;
 
     // This is a low-level test where we call checkAndMarkPointer. This method
     // causes the object start bitmap to be computed which requires the heap
     // to be in a consistent state (e.g. the free allocation area must be put
     // into a free list header). However when we call makeConsistentForGC it
     // also clears out the freelists so we have to rebuild those before trying
     // to allocate anything again. We do this by forcing a GC after doing the
     // checkAndMarkPointer tests.
     {
-        TestGCScope scope(ThreadState::HeapPointersOnStack);
+        TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked()); // Fail the test if we could not park all threads.
         Heap::flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
         }
         EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
         visitor.reset();
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
         EXPECT_EQ(2ul, visitor.count());
         visitor.reset();
     }
     // This forces a GC without stack scanning which results in the objects
     // being collected. This will also rebuild the above mentioned freelists,
     // however we don't rely on that below since we don't have any allocations.
     clearOutOldGarbage();
     {
-        TestGCScope scope(ThreadState::HeapPointersOnStack);
+        TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked());
         Heap::flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             // We would like to assert that checkAndMarkPointer returned false
             // here because the pointers no longer point into a valid object
             // (it's been freed by the GCs. But checkAndMarkPointer will return
             // true for any pointer that points into a heap page, regardless of
             // whether it points at a valid object (this ensures the
             // correctness of the page-based on-heap address caches), so we
             // can't make that assert.
@@ skipping 806 matching lines @@
         OwnPtr<WebThread> sleepingThread = adoptPtr(Platform::current()->createThread("SleepingThread"));
         sleepingThread->taskRunner()->postTask(FROM_HERE, new Task(threadSafeBind(sleeperMainFunc)));
 
         // Wait for the sleeper to run.
         while (!s_sleeperRunning) {
             Platform::current()->yieldCurrentThread();
         }
 
         {
             // Expect the first attempt to park the sleeping thread to fail
-            TestGCScope scope(ThreadState::NoHeapPointersOnStack);
+            TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
             EXPECT_FALSE(scope.allThreadsParked());
         }
 
         s_sleeperDone = true;
 
         // Wait for the sleeper to finish.
         while (s_sleeperRunning) {
             // We enter the safepoint here since the sleeper thread will detach
             // causing it to GC.
-            ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
+            ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
 
         {
             // Since the sleeper thread has detached this is the only thread.
-            TestGCScope scope(ThreadState::NoHeapPointersOnStack);
+            TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
             EXPECT_TRUE(scope.allThreadsParked());
         }
     }
 
 private:
     static void sleeperMainFunc()
     {
         ThreadState::attach();
         s_sleeperRunning = true;
 
@@ skipping 693 matching lines @@
             s_workerObjectPointer = reinterpret_cast<uintptr_t>(workerObject);
         }
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
 
         {
             // Wait for the main thread to do two GCs without sweeping this thread
             // heap. The worker waits within a safepoint, but there is no sweeping
             // until leaving the safepoint scope.
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             parkWorkerThread();
         }
 
         // Wake up the main thread when done sweeping.
         wakeMainThread();
 
         // Wait with detach until the main thread says so. This is not strictly
         // necessary, but it means the worker thread will not do its thread local
         // GCs just yet, making it easier to reason about that no new GC has occurred
         // and the above sweep was the one finalizing the worker object.
@@ skipping 35 matching lines @@
         preciselyCollectGarbage();
         preciselyCollectGarbage();
 
         // Wake up the worker thread so it can continue. It will sweep
         // and perform another GC where the backing store of its
         // collection should be strongified.
         wakeWorkerThread();
 
         // Wait for the worker thread to sweep its heaps before checking.
         {
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             parkMainThread();
         }
     }
 
 private:
 
     using WeakCollectionType = HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>>;
 
     static WeakCollectionType* allocateCollection()
     {
@@ skipping 17 matching lines @@
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
 
         {
             // Wait for the main thread to do two GCs without sweeping
             // this thread heap. The worker waits within a safepoint,
             // but there is no sweeping until leaving the safepoint
             // scope. If the weak collection backing is marked dead
             // because of this we will not get strongification in the
             // GC we force when we continue.
-            SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+            SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             parkWorkerThread();
         }
 
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
@@ skipping 170 matching lines @@
         // Wait for the main thread to get the global lock to ensure it has
         // it before the worker tries to acquire it. We want the worker to
         // block in the SafePointAwareMutexLocker until the main thread
         // has done a GC. The GC will not mark the "dlo" object since the worker
         // is entering the safepoint with NoHeapPointersOnStack. When the worker
         // subsequently gets the global lock and leaves the safepoint it will
         // sweep its heap and finalize "dlo". The destructor of "dlo" will try
         // to acquire the same global lock that the thread just got and deadlock
         // unless the global lock is recursive.
         parkWorkerThread();
-        SafePointAwareMutexLocker recursiveLocker(recursiveMutex(), ThreadState::NoHeapPointersOnStack);
+        SafePointAwareMutexLocker recursiveLocker(recursiveMutex(), BlinkGC::NoHeapPointersOnStack);
 
         // We won't get here unless the lock is recursive since the sweep done
         // in the constructor of SafePointAwareMutexLocker after
         // getting the lock will not complete given the "dlo" destructor is
         // waiting to get the same lock.
         // Tell the main thread the worker has done its sweep.
         wakeMainThread();
 
         ThreadState::detach();
     }
@@ skipping 700 matching lines @@
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
     ThreadState::attach();
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();
 
     // Step 4: Run a GC.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, Heap::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
     ThreadState::detach();
     wakeMainThread();
 }
 
 } // anonymous namespace
 
@@ skipping 16 matching lines @@
     ASSERT_TRUE(object);
     CrossThreadWeakPersistent<DestructorLockingObject> crossThreadWeakPersistent(object);
     object = nullptr;
     {
         SafePointAwareMutexLocker recursiveMutexLocker(recursiveMutex());
         EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
     }
 
     {
         // Pretend we have no pointers on stack during the step 4.
-        SafePointScope scope(ThreadState::NoHeapPointersOnStack);
+        SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
         wakeWorkerThread();
         parkMainThread();
     }
 
     // Step 5: Make sure the weak persistent is cleared.
     EXPECT_FALSE(crossThreadWeakPersistent.get());
     {
         SafePointAwareMutexLocker recursiveMutexLocker(recursiveMutex());
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
     }
 
     wakeWorkerThread();
     parkMainThread();
 }
 
 } // namespace blink