Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/HeapTest.cpp

Index: third_party/WebKit/Source/platform/heap/HeapTest.cpp
diff --git a/third_party/WebKit/Source/platform/heap/HeapTest.cpp b/third_party/WebKit/Source/platform/heap/HeapTest.cpp
index d455f824447f8f211a7eede554e239bd56ba450e..710cccd234120dcefcbae005b5ed92d58bee580c 100644
--- a/third_party/WebKit/Source/platform/heap/HeapTest.cpp
+++ b/third_party/WebKit/Source/platform/heap/HeapTest.cpp
@@ -243,7 +243,7 @@ public:
         , m_parkedAllThreads(false)
     {
         ASSERT(m_state->checkThread());
-        if (LIKELY(ThreadState::stopThreads())) {
+        if (LIKELY(m_state->gcGroup()->park())) {
             Heap::preGC();
             m_parkedAllThreads = true;
         }
@@ -257,7 +257,7 @@ public:
         // and we need to resume the other threads.
         if (LIKELY(m_parkedAllThreads)) {
             Heap::postGC(BlinkGC::GCWithSweep);
-            ThreadState::resumeThreads();
+            m_state->gcGroup()->resume();
         }
     }
 
@@ -281,8 +281,8 @@ private:
 
 class CountingVisitor : public Visitor {
 public:
-    CountingVisitor()
-        : Visitor(Visitor::ThreadLocalMarking)
+    CountingVisitor(GCData* gcData)

[haraken, 2016/01/28 15:52:50]

Add explicit.

[keishi, 2016/02/29 06:02:33]

Done.

+        : Visitor(Visitor::ThreadLocalMarking, gcData)
         , m_count(0)
     {
     }
@@ -514,7 +514,7 @@ protected:
     void runThread() override
     {
         OwnPtr<GlobalIntWrapperPersistent> longLivingPersistent;
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         longLivingPersistent = createGlobalPersistent(0x2a2a2a2a);
         int gcCount = 0;
@@ -573,7 +573,7 @@ public:
 private:
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         int gcCount = 0;
         while (!done()) {
@@ -667,7 +667,7 @@ protected:
 
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         PersistentChain::create(100);
 
@@ -1032,8 +1032,9 @@ int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 
 class RefCountedGarbageCollectedVisitor : public CountingVisitor {
 public:
-    RefCountedGarbageCollectedVisitor(int expected, void** objects)
-        : m_count(0)
+    RefCountedGarbageCollectedVisitor(int expected, void** objects, GCData* gcData)
+        : CountingVisitor(gcData)
+        , m_count(0)
         , m_expectedCount(expected)
         , m_expectedObjects(objects)
     {
@@ -1771,7 +1772,7 @@ TEST(HeapTest, BasicFunctionality)
         size_t baseLevel = initialObjectPayloadSize;
         bool testPagesAllocated = !baseLevel;
         if (testPagesAllocated)
-            EXPECT_EQ(Heap::allocatedSpace(), 0ul);
+            EXPECT_EQ(ThreadState::current()->gcGroup()->heapStats().allocatedSpace(), 0ul);
 
         // This allocates objects on the general heap which should add a page of memory.
         DynamicallySizedObject* alloc32 = DynamicallySizedObject::create(32);
@@ -1785,7 +1786,7 @@ TEST(HeapTest, BasicFunctionality)
 
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(Heap::allocatedSpace(), blinkPageSize * 2);
+            EXPECT_EQ(ThreadState::current()->gcGroup()->heapStats().allocatedSpace(), blinkPageSize * 2);
 
         EXPECT_EQ(alloc32->get(0), 40);
         EXPECT_EQ(alloc32->get(31), 40);
@@ -1806,7 +1807,7 @@ TEST(HeapTest, BasicFunctionality)
     size_t baseLevel = Heap::objectPayloadSizeForTesting();
     bool testPagesAllocated = !baseLevel;
     if (testPagesAllocated)
-        EXPECT_EQ(Heap::allocatedSpace(), 0ul);
+        EXPECT_EQ(ThreadState::current()->gcGroup()->heapStats().allocatedSpace(), 0ul);
 
     size_t big = 1008;
     Persistent<DynamicallySizedObject> bigArea = DynamicallySizedObject::create(big);
@@ -1824,7 +1825,7 @@ TEST(HeapTest, BasicFunctionality)
         slack += 4;
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, ThreadState::current()->gcGroup()->heapStats().allocatedSpace() & (blinkPageSize - 1));
     }
 
     {
@@ -1839,14 +1840,14 @@ TEST(HeapTest, BasicFunctionality)
         total += 96;
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, ThreadState::current()->gcGroup()->heapStats().allocatedSpace() & (blinkPageSize - 1));
     }
 
     clearOutOldGarbage();
     total -= 96;
     slack -= 8;
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->gcGroup()->heapStats().allocatedSpace() & (blinkPageSize - 1));
 
     // Clear the persistent, so that the big area will be garbage collected.
     bigArea.release();
@@ -1856,11 +1857,11 @@ TEST(HeapTest, BasicFunctionality)
     slack -= 4;
     CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->gcGroup()->heapStats().allocatedSpace() & (blinkPageSize - 1));
 
     CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->gcGroup()->heapStats().allocatedSpace() & (blinkPageSize - 1));
 
     for (size_t i = 0; i < persistentCount; i++) {
         delete persistents[i];
@@ -2323,7 +2324,7 @@ TEST(HeapTest, LargeHeapObjects)
 {
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
-    size_t initialAllocatedSpace = Heap::allocatedSpace();
+    size_t initialAllocatedSpace = ThreadState::current()->gcGroup()->heapStats().allocatedSpace();
     IntWrapper::s_destructorCalls = 0;
     LargeHeapObject::s_destructorCalls = 0;
     {
@@ -2332,7 +2333,7 @@ TEST(HeapTest, LargeHeapObjects)
         ASSERT(ThreadState::current()->findPageFromAddress(object));
         ASSERT(ThreadState::current()->findPageFromAddress(reinterpret_cast<char*>(object.get()) + sizeof(LargeHeapObject) - 1));
         clearOutOldGarbage();
-        size_t afterAllocation = Heap::allocatedSpace();
+        size_t afterAllocation = ThreadState::current()->gcGroup()->heapStats().allocatedSpace();
         {
             object->set(0, 'a');
             EXPECT_EQ('a', object->get(0));
@@ -2356,13 +2357,13 @@ TEST(HeapTest, LargeHeapObjects)
                 object = LargeHeapObject::create();
         }
         clearOutOldGarbage();
-        EXPECT_TRUE(Heap::allocatedSpace() == afterAllocation);
+        EXPECT_TRUE(ThreadState::current()->gcGroup()->heapStats().allocatedSpace() == afterAllocation);
         EXPECT_EQ(10, IntWrapper::s_destructorCalls);
         EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
     }
     clearOutOldGarbage();
     EXPECT_TRUE(initialObjectPayloadSize == Heap::objectPayloadSizeForTesting());
-    EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
+    EXPECT_TRUE(initialAllocatedSpace == ThreadState::current()->gcGroup()->heapStats().allocatedSpace());
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeHeapObject::s_destructorCalls);
     preciselyCollectGarbage();
@@ -3595,7 +3596,8 @@ TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
             pointer1 = object1.get();
             pointer2 = object2.get();
             void* objects[2] = { object1.get(), object2.get() };
-            RefCountedGarbageCollectedVisitor visitor(2, objects);
+            GCData gcData(ThreadState::current(), BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep);
+            RefCountedGarbageCollectedVisitor visitor(2, objects, &gcData);
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
@@ -3610,7 +3612,8 @@ TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
         // At this point, the reference counts of object1 and object2 are 0.
         // Only pointer1 and pointer2 keep references to object1 and object2.
         void* objects[] = { 0 };
-        RefCountedGarbageCollectedVisitor visitor(0, objects);
+        GCData gcData(ThreadState::current(), BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep);
+        RefCountedGarbageCollectedVisitor visitor(0, objects, &gcData);
         ThreadState::current()->visitPersistents(&visitor);
         EXPECT_TRUE(visitor.validate());
 
@@ -3618,7 +3621,8 @@ TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
             Persistent<RefCountedAndGarbageCollected> object1(pointer1);
             Persistent<RefCountedAndGarbageCollected2> object2(pointer2);
             void* objects[2] = { object1.get(), object2.get() };
-            RefCountedGarbageCollectedVisitor visitor(2, objects);
+            GCData gcData(ThreadState::current(), BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep);
+            RefCountedGarbageCollectedVisitor visitor(2, objects, &gcData);
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
@@ -3768,7 +3772,8 @@ TEST(HeapTest, CheckAndMarkPointer)
     Vector<Address> endAddresses;
     Address largeObjectAddress;
     Address largeObjectEndAddress;
-    CountingVisitor visitor;
+    GCData gcData(ThreadState::current(), BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep);
+    CountingVisitor visitor(&gcData);
     for (int i = 0; i < 10; i++) {
         SimpleObject* object = SimpleObject::create();
         Address objectAddress = reinterpret_cast<Address>(object);
@@ -3789,7 +3794,7 @@ TEST(HeapTest, CheckAndMarkPointer)
     {
         TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked()); // Fail the test if we could not park all threads.
-        Heap::flushHeapDoesNotContainCache();
+        ThreadState::current()->gcGroup()->flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
@@ -3808,7 +3813,7 @@ TEST(HeapTest, CheckAndMarkPointer)
     {
         TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked());
-        Heap::flushHeapDoesNotContainCache();
+        ThreadState::current()->gcGroup()->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
@@ -4734,7 +4739,7 @@ public:
 private:
     static void sleeperMainFunc()
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
         s_sleeperRunning = true;
 
         // Simulate a long running op that is not entering a safepoint.
@@ -5424,7 +5429,7 @@ private:
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         {
             // Create a worker object that is not kept alive except the
@@ -5545,7 +5550,7 @@ private:
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         {
             Persistent<WeakCollectionType> collection = allocateCollection();
@@ -5706,7 +5711,7 @@ private:
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         DestructorLockingObject* dlo = DestructorLockingObject::create();
         ASSERT_UNUSED(dlo, dlo);
@@ -5761,7 +5766,7 @@ public:
         wakeWorkerThread();
 
         parkMainThread();
-        ThreadState::attachMainThread();
+        ThreadState::prepareForMainThread();
     }
 
 private:
@@ -5774,7 +5779,7 @@ private:
         // Do this to verify that CrossThreadPersistent<>s referring to objects
         // on one of the main thread's heaps does not upset the CTP invalidation
         // pass that ThreadState::detach() performs.
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         CrossThreadPersistent<IntWrapper> persistent(IntWrapper::create(43));
 
@@ -5818,7 +5823,8 @@ private:
 
 TEST(HeapTest, TraceIfNeeded)
 {
-    CountingVisitor visitor;
+    GCData gcData(ThreadState::current(), BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep);
+    CountingVisitor visitor(&gcData);
 
     {
         TraceIfNeededTester<RefPtr<OffHeapInt>>* m_offHeap = TraceIfNeededTester<RefPtr<OffHeapInt>>::create(OffHeapInt::create(42));
@@ -6441,7 +6447,7 @@ void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject**
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
-    ThreadState::attach();
+    ThreadState::prepareForCurrentThread();
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();