Refactor the Heap into ThreadHeap to prepare for per thread heaps

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 225 matching lines @@
 namespace blink {
 
 class TestGCScope {
 public:
     explicit TestGCScope(BlinkGC::StackState state)
         : m_state(ThreadState::current())
         , m_safePointScope(state)
         , m_parkedAllThreads(false)
     {
         ASSERT(m_state->checkThread());
-        if (LIKELY(ThreadState::stopThreads())) {
+        if (LIKELY(m_state->gcGroup()->park())) {
             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(BlinkGC::GCWithSweep);
-            ThreadState::resumeThreads();
+            m_state->gcGroup()->resume();
         }
     }
 
 private:
     ThreadState* m_state;
     SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 #define DEFINE_VISITOR_METHODS(Type)                               \
     void mark(const Type* object, TraceCallback callback) override \
     {                                                              \
         if (object)                                                \
             m_count++;                                             \
     }                                                              \
     bool isMarked(const Type*) override { return false; }          \
     bool ensureMarked(const Type* objectPointer) override          \
     {                                                              \
         return ensureMarked(objectPointer);                        \
     }
 
 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)
     {
     }
 
     void mark(const void* object, TraceCallback) override
     {
         if (object)
             m_count++;
     }
 
@@ skipping 211 matching lines @@
     using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
     PassOwnPtr<GlobalIntWrapperPersistent> createGlobalPersistent(int value)
     {
         return adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(value)));
     }
 
     void runThread() override
     {
         OwnPtr<GlobalIntWrapperPersistent> longLivingPersistent;
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         longLivingPersistent = createGlobalPersistent(0x2a2a2a2a);
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 OwnPtr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
 
@@ skipping 38 matching lines @@
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         int gcCount = 0;
         while (!done()) {
             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));
@@ skipping 73 matching lines @@
         explicit PersistentChain(int count)
         {
             m_refCountedChain = adoptRef(RefCountedChain::create(count));
         }
 
         RefPtr<RefCountedChain> m_refCountedChain;
     };
 
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         PersistentChain::create(100);
 
         // Upon thread detach, GCs will run until all persistents have been
         // released. We verify that the draining of persistents proceeds
         // as expected by dropping one Persistent<> per GC until there
         // are none left.
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
@@ skipping 344 matching lines @@
 int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 
 #define DEFINE_VISITOR_METHODS(Type)                               \
     void mark(const Type* object, TraceCallback callback) override \
     {                                                              \
         mark(object);                                              \
     }                                                              \
 
 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)
     {
     }
 
     void mark(const void* ptr) { markNoTrace(ptr); }
 
     virtual void markNoTrace(const void* ptr)
     {
         if (!ptr)
@@ skipping 717 matching lines @@
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
     {
         size_t slack = 0;
 
         // When the test starts there may already have been leaked some memory
         // on the heap, so we establish a base line.
         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);
         slack += 4;
         memset(alloc32, 40, 32);
         DynamicallySizedObject* alloc64 = DynamicallySizedObject::create(64);
         slack += 4;
         memset(alloc64, 27, 64);
 
         size_t total = 96;
 
         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);
         EXPECT_EQ(alloc64->get(0), 27);
         EXPECT_EQ(alloc64->get(63), 27);
 
         conservativelyCollectGarbage();
 
         EXPECT_EQ(alloc32->get(0), 40);
         EXPECT_EQ(alloc32->get(31), 40);
         EXPECT_EQ(alloc64->get(0), 27);
         EXPECT_EQ(alloc64->get(63), 27);
     }
 
     clearOutOldGarbage();
     size_t total = 0;
     size_t slack = 0;
     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);
     total += big;
     slack += 4;
 
     size_t persistentCount = 0;
     const size_t numPersistents = 100000;
     Persistent<DynamicallySizedObject>* persistents[numPersistents];
 
     for (int i = 0; i < 1000; i++) {
         size_t size = 128 + i * 8;
         total += size;
         persistents[persistentCount++] = new Persistent<DynamicallySizedObject>(DynamicallySizedObject::create(size));
         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));
     }
 
     {
         DynamicallySizedObject* alloc32b(DynamicallySizedObject::create(32));
         slack += 4;
         memset(alloc32b, 40, 32);
         DynamicallySizedObject* alloc64b(DynamicallySizedObject::create(64));
         slack += 4;
         memset(alloc64b, 27, 64);
         EXPECT_TRUE(alloc32b != alloc64b);
 
         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();
     clearOutOldGarbage();
 
     total -= big;
     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];
         persistents[i] = 0;
     }
 
     uint8_t* address = reinterpret_cast<uint8_t*>(Heap::allocate<DynamicallySizedObject>(100));
     for (int i = 0; i < 100; i++)
         address[i] = i;
     address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 100000));
@@ skipping 442 matching lines @@
     }
     clearOutOldGarbage();
     size_t afterFree = Heap::objectPayloadSizeForTesting();
     EXPECT_TRUE(initialObjectPayloadSize == afterFree);
 }
 
 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;
     {
         int slack = 8; // LargeHeapObject points to an IntWrapper that is also allocated.
         Persistent<LargeHeapObject> object = LargeHeapObject::create();
         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));
             object->set(object->length() - 1, 'b');
             EXPECT_EQ('b', object->get(object->length() - 1));
             size_t expectedLargeHeapObjectPayloadSize = Heap::allocationSizeFromSize(sizeof(LargeHeapObject));
             size_t expectedObjectPayloadSize = expectedLargeHeapObjectPayloadSize + sizeof(IntWrapper);
             size_t actualObjectPayloadSize = Heap::objectPayloadSizeForTesting() - initialObjectPayloadSize;
             CheckWithSlack(expectedObjectPayloadSize, actualObjectPayloadSize, slack);
             // There is probably space for the IntWrapper in a heap page without
             // allocating extra pages. However, the IntWrapper allocation might cause
             // the addition of a heap page.
             size_t largeObjectAllocationSize = sizeof(LargeObjectPage) + expectedLargeHeapObjectPayloadSize;
             size_t allocatedSpaceLowerBound = initialAllocatedSpace + largeObjectAllocationSize;
             size_t allocatedSpaceUpperBound = allocatedSpaceLowerBound + slack + blinkPageSize;
             EXPECT_LE(allocatedSpaceLowerBound, afterAllocation);
             EXPECT_LE(afterAllocation, allocatedSpaceUpperBound);
             EXPECT_EQ(0, IntWrapper::s_destructorCalls);
             EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
             for (int i = 0; i < 10; i++)
                 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();
 }
 
 typedef std::pair<Member<IntWrapper>, int> PairWrappedUnwrapped;
 typedef std::pair<int, Member<IntWrapper>> PairUnwrappedWrapped;
 typedef std::pair<WeakMember<IntWrapper>, Member<IntWrapper>> PairWeakStrong;
 typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> PairStrongWeak;
 typedef std::pair<WeakMember<IntWrapper>, int> PairWeakUnwrapped;
@@ skipping 1212 matching lines @@
     RefCountedAndGarbageCollected2::s_destructorCalls = 0;
     {
         RefCountedAndGarbageCollected* pointer1 = 0;
         RefCountedAndGarbageCollected2* pointer2 = 0;
         {
             Persistent<RefCountedAndGarbageCollected> object1 = RefCountedAndGarbageCollected::create();
             Persistent<RefCountedAndGarbageCollected2> object2 = RefCountedAndGarbageCollected2::create();
             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());
 
             conservativelyCollectGarbage();
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
         conservativelyCollectGarbage();
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
         EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
         // 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());
 
         {
             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());
 
             conservativelyCollectGarbage();
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
 
         conservativelyCollectGarbage();
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
@@ skipping 129 matching lines @@
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
 {
     clearOutOldGarbage();
 
     Vector<Address> objectAddresses;
     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);
         objectAddresses.append(objectAddress);
         endAddresses.append(objectAddress + sizeof(SimpleObject) - 1);
     }
     LargeHeapObject* largeObject = LargeHeapObject::create();
     largeObjectAddress = reinterpret_cast<Address>(largeObject);
     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(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]));
         }
         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(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
             // (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.
             Heap::checkAndMarkPointer(&visitor, objectAddresses[i]);
             Heap::checkAndMarkPointer(&visitor, endAddresses[i]);
@@ skipping 905 matching lines @@
         {
             // Since the sleeper thread has detached this is the only thread.
             TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
             EXPECT_TRUE(scope.allThreadsParked());
         }
     }
 
 private:
     static void sleeperMainFunc()
     {
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
         s_sleeperRunning = true;
 
         // Simulate a long running op that is not entering a safepoint.
         while (!s_sleeperDone) {
             Platform::current()->yieldCurrentThread();
         }
 
         ThreadState::detach();
         s_sleeperRunning = false;
     }
@@ skipping 669 matching lines @@
         // shutdown.
         wakeWorkerThread();
     }
 
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         {
             // Create a worker object that is not kept alive except the
             // main thread will keep it as an integer value on its stack.
             IntWrapper* workerObject = IntWrapper::create(42);
             s_workerObjectPointer = reinterpret_cast<uintptr_t>(workerObject);
         }
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
@@ skipping 100 matching lines @@
             parkWorkerThread();
         }
 
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         {
             Persistent<WeakCollectionType> collection = allocateCollection();
             {
                 // Prevent weak processing with an iterator and GC.
                 WeakCollectionType::iterator it = collection->begin();
                 conservativelyCollectGarbage();
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
@@ skipping 140 matching lines @@
         // can acquire it and do its sweep of its heaps. Just wait for the worker
         // to complete its sweep and check the result.
         parkMainThread();
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
     }
 
 private:
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
-        ThreadState::attach();
+        ThreadState::prepareForCurrentThread();
 
         DestructorLockingObject* dlo = DestructorLockingObject::create();
         ASSERT_UNUSED(dlo, dlo);
 
         // Wake up the main thread which is waiting for the worker to do its
         // allocation.
         wakeMainThread();
 
         // 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
@@ skipping 34 matching lines @@
         workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
 
         parkMainThread();
 
         // (Temporarily) detach main thread and wake the worker thread, so that it
         // can do its detach().
         ThreadState::detachMainThread();
         wakeWorkerThread();
 
         parkMainThread();
-        ThreadState::attachMainThread();
+        ThreadState::prepareForMainThread();
     }
 
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
         // Start up a worker thread and have it detach after the main thread has.
         // 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));
 
         // Wait for the main thread to detach.
         wakeMainThread();
         parkWorkerThread();
 
         ThreadState::detach();
         wakeMainThread();
     }
@@ skipping 23 matching lines @@
     DISALLOW_NEW();
 public:
     PartObject() : m_obj(SimpleObject::create()) { }
     DEFINE_INLINE_TRACE() { visitor->trace(m_obj); }
 private:
     Member<SimpleObject> m_obj;
 };
 
 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));
         visitor.reset();
         m_offHeap->trace(&visitor);
         EXPECT_EQ(0u, visitor.count());
     }
 
     {
         TraceIfNeededTester<PartObject>* m_part = TraceIfNeededTester<PartObject>::create();
@@ skipping 602 matching lines @@
     preciselyCollectGarbage();
     EXPECT_FALSE(holder->object());
 }
 
 namespace {
 
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
-    ThreadState::attach();
+    ThreadState::prepareForCurrentThread();
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();
 
     // Step 4: Run a GC.
     Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
@@ skipping 69 matching lines @@
     EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     EXPECT_EQ(16u, vector1.capacity());
     EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 } // namespace blink