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 30 matching lines @@
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
 
 namespace blink {
 
 static void preciselyCollectGarbage()
 {
-    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
 }
 
 static void conservativelyCollectGarbage()
 {
-    Heap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
 }
 
 class IntWrapper : public GarbageCollectedFinalized<IntWrapper> {
 public:
     static IntWrapper* create(int x)
     {
         return new IntWrapper(x);
     }
 
     virtual ~IntWrapper()
@@ skipping 83 matching lines @@
     bool isHashTableDeletedValue() const { return first == reinterpret_cast<IntWrapper*>(-1); }
 
     // Since we don't allocate independent objects of this type, we don't need
     // a regular trace method. Instead, we use a traceInCollection method. If
     // the entry should be deleted from the collection we return true and don't
     // trace the strong pointer.
     template<typename VisitorDispatcher>
     bool traceInCollection(VisitorDispatcher visitor, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         visitor->traceInCollection(second, strongify);
-        if (!Heap::isHeapObjectAlive(second))
+        if (!ThreadHeap::isHeapObjectAlive(second))
             return true;
         // FIXME: traceInCollection is also called from WeakProcessing to check if the entry is dead.
         // The below if avoids calling trace in that case by only calling trace when |first| is not yet marked.
-        if (!Heap::isHeapObjectAlive(first))
+        if (!ThreadHeap::isHeapObjectAlive(first))
             visitor->trace(first);
         return false;
     }
 };
 
 template<typename T> struct WeakHandlingHashTraits : WTF::SimpleClassHashTraits<T> {
     // We want to treat the object as a weak object in the sense that it can
     // disappear from hash sets and hash maps.
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     // Normally whether or not an object needs tracing is inferred
@@ skipping 62 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())) {
-            Heap::preGC();
+        if (LIKELY(m_state->heap().park())) {
+            m_state->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->heap().postGC(BlinkGC::GCWithSweep);
+            m_state->heap().resume();
         }
     }
 
 private:
     ThreadState* m_state;
     SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 #define DEFINE_VISITOR_METHODS(Type)                               \
@@ skipping 135 matching lines @@
     DEFINE_INLINE_TRACE() { }
 private:
     static const int s_arraySize = 1000;
     int8_t m_array[s_arraySize];
 };
 
 // Do several GCs to make sure that later GCs don't free up old memory from
 // previously run tests in this process.
 static void clearOutOldGarbage()
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     while (true) {
-        size_t used = Heap::objectPayloadSizeForTesting();
+        size_t used = heap.objectPayloadSizeForTesting();
         preciselyCollectGarbage();
-        if (Heap::objectPayloadSizeForTesting() >= used)
+        if (heap.objectPayloadSizeForTesting() >= used)
             break;
     }
 }
 
 class OffHeapInt : public RefCounted<OffHeapInt> {
 public:
     static RefPtr<OffHeapInt> create(int x)
     {
         return adoptRef(new OffHeapInt(x));
     }
@@ skipping 106 matching lines @@
 
                 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(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
+                // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
                 preciselyCollectGarbage();
                 EXPECT_EQ(wrapper->value(), 0x0bbac0de);
                 EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
             }
             SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             testing::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();
+        ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
@@ skipping 19 matching lines @@
 
                 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(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
+                // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
                 preciselyCollectGarbage();
                 EXPECT_TRUE(weakMap->isEmpty());
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
             SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             testing::yieldCurrentThread();
         }
-        ThreadState::detach();
+        ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadPersistentHeapTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadPersistentHeapTester);
     }
@@ skipping 48 matching lines @@
     void runThread() override
     {
         ThreadState::attach();
 
         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();
+        ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 // The accounting for memory includes the memory used by rounding up object
 // sizes. This is done in a different way on 32 bit and 64 bit, so we have to
 // have some slack in the tests.
 template<typename T>
 void CheckWithSlack(T expected, T actual, int slack)
 {
@@ skipping 23 matching lines @@
 
 class ClassWithMember : public GarbageCollected<ClassWithMember> {
 public:
     static ClassWithMember* create()
     {
         return new ClassWithMember();
     }
 
     DEFINE_INLINE_TRACE()
     {
-        EXPECT_TRUE(Heap::isHeapObjectAlive(this));
+        EXPECT_TRUE(ThreadHeap::isHeapObjectAlive(this));
         if (!traceCount())
-            EXPECT_FALSE(Heap::isHeapObjectAlive(m_traceCounter));
+            EXPECT_FALSE(ThreadHeap::isHeapObjectAlive(m_traceCounter));
         else
-            EXPECT_TRUE(Heap::isHeapObjectAlive(m_traceCounter));
+            EXPECT_TRUE(ThreadHeap::isHeapObjectAlive(m_traceCounter));
 
         visitor->trace(m_traceCounter);
     }
 
     int traceCount() { return m_traceCounter->traceCount(); }
 
 private:
     ClassWithMember()
         : m_traceCounter(TraceCounter::create())
     { }
@@ skipping 31 matching lines @@
     // 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();
         const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(IntNode);
-        return Heap::allocateOnArenaIndex(state, size, BlinkGC::NodeArenaIndex, GCInfoTrait<IntNode>::index(), typeName);
+        return ThreadHeap::allocateOnArenaIndex(state, size, BlinkGC::NodeArenaIndex, GCInfoTrait<IntNode>::index(), typeName);
     }
 
     static IntNode* create(int i)
     {
         return new IntNode(i);
     }
 
     DEFINE_INLINE_TRACE() { }
 
     int value() { return m_value; }
@@ skipping 303 matching lines @@
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_strongBar);
         visitor->template registerWeakMembers<Weak, &Weak::zapWeakMembers>(this);
     }
 
     void zapWeakMembers(Visitor* visitor)
     {
-        if (!Heap::isHeapObjectAlive(m_weakBar))
+        if (!ThreadHeap::isHeapObjectAlive(m_weakBar))
             m_weakBar = 0;
     }
 
     bool strongIsThere() { return !!m_strongBar; }
     bool weakIsThere() { return !!m_weakBar; }
 
 private:
     Weak(Bar* strongBar, Bar* weakBar)
         : Bar()
         , m_strongBar(strongBar)
@@ skipping 174 matching lines @@
     static FinalizationObserver* create(T* data) { return new FinalizationObserver(data); }
     bool didCallWillFinalize() const { return m_didCallWillFinalize; }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->template registerWeakMembers<FinalizationObserver<T>, &FinalizationObserver<T>::zapWeakMembers>(this);
     }
 
     void zapWeakMembers(Visitor* visitor)
     {
-        if (m_data && !Heap::isHeapObjectAlive(m_data)) {
+        if (m_data && !ThreadHeap::isHeapObjectAlive(m_data)) {
             m_data->willFinalize();
             m_data = nullptr;
             m_didCallWillFinalize = true;
         }
     }
 
 private:
     FinalizationObserver(T* data)
         : m_data(data)
         , m_didCallWillFinalize(false)
@@ skipping 303 matching lines @@
     static const size_t s_length = 1024;
     char m_data[s_length];
 };
 
 int OneKiloByteObject::s_destructorCalls = 0;
 
 class DynamicallySizedObject : public GarbageCollected<DynamicallySizedObject> {
 public:
     static DynamicallySizedObject* create(size_t size)
     {
-        void* slot = Heap::allocate<DynamicallySizedObject>(size);
+        void* slot = ThreadHeap::allocate<DynamicallySizedObject>(size);
         return new (slot) DynamicallySizedObject();
     }
 
     void* operator new(std::size_t, void* location)
     {
         return location;
     }
 
     uint8_t get(int i)
     {
@@ skipping 124 matching lines @@
     ThreadedWeaknessTester::test();
 }
 
 TEST(HeapTest, ThreadPersistent)
 {
     ThreadPersistentHeapTester::test();
 }
 
 TEST(HeapTest, BasicFunctionality)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     clearOutOldGarbage();
-    size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
+    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(heap.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);
+        CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(Heap::allocatedSpace(), blinkPageSize * 2);
+            EXPECT_EQ(heap.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();
+    size_t baseLevel = heap.objectPayloadSizeForTesting();
     bool testPagesAllocated = !baseLevel;
     if (testPagesAllocated)
-        EXPECT_EQ(Heap::allocatedSpace(), 0ul);
+        EXPECT_EQ(heap.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);
+        CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, heap.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);
+        CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, heap.heapStats().allocatedSpace() & (blinkPageSize - 1));
     }
 
     clearOutOldGarbage();
     total -= 96;
     slack -= 8;
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, heap.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);
+    CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, heap.heapStats().allocatedSpace() & (blinkPageSize - 1));
 
-    CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
+    CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, heap.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));
+    uint8_t* address = reinterpret_cast<uint8_t*>(ThreadHeap::allocate<DynamicallySizedObject>(100));
     for (int i = 0; i < 100; i++)
         address[i] = i;
-    address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 100000));
+    address = reinterpret_cast<uint8_t*>(ThreadHeap::reallocate<DynamicallySizedObject>(address, 100000));
     for (int i = 0; i < 100; i++)
         EXPECT_EQ(address[i], i);
-    address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 50));
+    address = reinterpret_cast<uint8_t*>(ThreadHeap::reallocate<DynamicallySizedObject>(address, 50));
     for (int i = 0; i < 50; i++)
         EXPECT_EQ(address[i], i);
     // This should be equivalent to free(address).
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(Heap::reallocate<DynamicallySizedObject>(address, 0)), 0ul);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(ThreadHeap::reallocate<DynamicallySizedObject>(address, 0)), 0ul);
     // This should be equivalent to malloc(0).
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(Heap::reallocate<DynamicallySizedObject>(0, 0)), 0ul);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(ThreadHeap::reallocate<DynamicallySizedObject>(0, 0)), 0ul);
 }
 
 TEST(HeapTest, SimpleAllocation)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     clearOutOldGarbage();
-    EXPECT_EQ(0ul, Heap::objectPayloadSizeForTesting());
+    EXPECT_EQ(0ul, heap.objectPayloadSizeForTesting());
 
     // Allocate an object in the heap.
     HeapAllocatedArray* array = new HeapAllocatedArray();
-    EXPECT_TRUE(Heap::objectPayloadSizeForTesting() >= sizeof(HeapAllocatedArray));
+    EXPECT_TRUE(heap.objectPayloadSizeForTesting() >= sizeof(HeapAllocatedArray));
 
     // Sanity check of the contents in the heap.
     EXPECT_EQ(0, array->at(0));
     EXPECT_EQ(42, array->at(42));
     EXPECT_EQ(0, array->at(128));
     EXPECT_EQ(999 % 128, array->at(999));
 }
 
 TEST(HeapTest, SimplePersistent)
 {
@@ skipping 56 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(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::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(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::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(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::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(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::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 119 matching lines @@
         // for the conservative stack scan to find.
         EXPECT_EQ(width, bars->getWidth());
     }
     EXPECT_EQ(Bars::width + 1, Bar::s_live);
     preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
 }
 
 TEST(HeapTest, HashMapOfMembers)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     IntWrapper::s_destructorCalls = 0;
 
     clearOutOldGarbage();
-    size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
+    size_t initialObjectPayloadSize = heap.objectPayloadSizeForTesting();
     {
         typedef HeapHashMap<
             Member<IntWrapper>,
             Member<IntWrapper>,
             DefaultHash<Member<IntWrapper>>::Hash,
             HashTraits<Member<IntWrapper>>,
             HashTraits<Member<IntWrapper>>> HeapObjectIdentityMap;
 
         Persistent<HeapObjectIdentityMap> map = new HeapObjectIdentityMap();
 
         map->clear();
-        size_t afterSetWasCreated = Heap::objectPayloadSizeForTesting();
+        size_t afterSetWasCreated = heap.objectPayloadSizeForTesting();
         EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
         preciselyCollectGarbage();
-        size_t afterGC = Heap::objectPayloadSizeForTesting();
+        size_t afterGC = heap.objectPayloadSizeForTesting();
         EXPECT_EQ(afterGC, afterSetWasCreated);
 
         // If the additions below cause garbage collections, these
         // pointers should be found by conservative stack scanning.
         IntWrapper* one(IntWrapper::create(1));
         IntWrapper* anotherOne(IntWrapper::create(1));
 
         map->add(one, one);
 
-        size_t afterOneAdd = Heap::objectPayloadSizeForTesting();
+        size_t afterOneAdd = heap.objectPayloadSizeForTesting();
         EXPECT_TRUE(afterOneAdd > afterGC);
 
         HeapObjectIdentityMap::iterator it(map->begin());
         HeapObjectIdentityMap::iterator it2(map->begin());
         ++it;
         ++it2;
 
         map->add(anotherOne, one);
 
         // The addition above can cause an allocation of a new
         // backing store. We therefore garbage collect before
         // taking the heap stats in order to get rid of the old
         // backing store. We make sure to not use conservative
         // stack scanning as that could find a pointer to the
         // old backing.
         preciselyCollectGarbage();
-        size_t afterAddAndGC = Heap::objectPayloadSizeForTesting();
+        size_t afterAddAndGC = heap.objectPayloadSizeForTesting();
         EXPECT_TRUE(afterAddAndGC >= afterOneAdd);
 
         EXPECT_EQ(map->size(), 2u); // Two different wrappings of '1' are distinct.
 
         preciselyCollectGarbage();
         EXPECT_TRUE(map->contains(one));
         EXPECT_TRUE(map->contains(anotherOne));
 
         IntWrapper* gotten(map->get(one));
         EXPECT_EQ(gotten->value(), one->value());
         EXPECT_EQ(gotten, one);
 
-        size_t afterGC2 = Heap::objectPayloadSizeForTesting();
+        size_t afterGC2 = heap.objectPayloadSizeForTesting();
         EXPECT_EQ(afterGC2, afterAddAndGC);
 
         IntWrapper* dozen = 0;
 
         for (int i = 1; i < 1000; i++) { // 999 iterations.
             IntWrapper* iWrapper(IntWrapper::create(i));
             IntWrapper* iSquared(IntWrapper::create(i * i));
             map->add(iWrapper, iSquared);
             if (i == 12)
                 dozen = iWrapper;
         }
-        size_t afterAdding1000 = Heap::objectPayloadSizeForTesting();
+        size_t afterAdding1000 = heap.objectPayloadSizeForTesting();
         EXPECT_TRUE(afterAdding1000 > afterGC2);
 
         IntWrapper* gross(map->get(dozen));
         EXPECT_EQ(gross->value(), 144);
 
         // This should clear out any junk backings created by all the adds.
         preciselyCollectGarbage();
-        size_t afterGC3 = Heap::objectPayloadSizeForTesting();
+        size_t afterGC3 = heap.objectPayloadSizeForTesting();
         EXPECT_TRUE(afterGC3 <= afterAdding1000);
     }
 
     preciselyCollectGarbage();
     // The objects 'one', anotherOne, and the 999 other pairs.
     EXPECT_EQ(IntWrapper::s_destructorCalls, 2000);
-    size_t afterGC4 = Heap::objectPayloadSizeForTesting();
+    size_t afterGC4 = heap.objectPayloadSizeForTesting();
     EXPECT_EQ(afterGC4, initialObjectPayloadSize);
 }
 
 TEST(HeapTest, NestedAllocation)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     clearOutOldGarbage();
-    size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
+    size_t initialObjectPayloadSize = heap.objectPayloadSizeForTesting();
     {
         Persistent<ConstructorAllocation> constructorAllocation = ConstructorAllocation::create();
     }
     clearOutOldGarbage();
-    size_t afterFree = Heap::objectPayloadSizeForTesting();
+    size_t afterFree = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(initialObjectPayloadSize == afterFree);
 }
 
 TEST(HeapTest, LargeHeapObjects)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     clearOutOldGarbage();
-    size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
-    size_t initialAllocatedSpace = Heap::allocatedSpace();
+    size_t initialObjectPayloadSize = heap.objectPayloadSizeForTesting();
+    size_t initialAllocatedSpace = heap.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 = heap.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 expectedLargeHeapObjectPayloadSize = ThreadHeap::allocationSizeFromSize(sizeof(LargeHeapObject));
             size_t expectedObjectPayloadSize = expectedLargeHeapObjectPayloadSize + sizeof(IntWrapper);
-            size_t actualObjectPayloadSize = Heap::objectPayloadSizeForTesting() - initialObjectPayloadSize;
+            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(ProcessHeap::totalAllocatedSpace() == 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(initialObjectPayloadSize == heap.objectPayloadSizeForTesting());
+    EXPECT_TRUE(initialAllocatedSpace == heap.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 1380 matching lines @@
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
     EXPECT_TRUE(barPersistent != fooPersistent);
     barPersistent = fooPersistent;
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
 {
+    ThreadHeap& heap = ThreadState::current()->heap();
     clearOutOldGarbage();
 
     Vector<Address> objectAddresses;
     Vector<Address> endAddresses;
     Address largeObjectAddress;
     Address largeObjectEndAddress;
     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);
         CountingVisitor visitor(ThreadState::current());
         EXPECT_TRUE(scope.allThreadsParked()); // Fail the test if we could not park all threads.
-        Heap::flushHeapDoesNotContainCache();
+        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_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_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);
         CountingVisitor visitor(ThreadState::current());
         EXPECT_TRUE(scope.allThreadsParked());
-        Heap::flushHeapDoesNotContainCache();
+        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.
-            Heap::checkAndMarkPointer(&visitor, objectAddresses[i]);
-            Heap::checkAndMarkPointer(&visitor, endAddresses[i]);
+            heap.checkAndMarkPointer(&visitor, objectAddresses[i]);
+            heap.checkAndMarkPointer(&visitor, endAddresses[i]);
         }
         EXPECT_EQ(0ul, visitor.count());
-        Heap::checkAndMarkPointer(&visitor, largeObjectAddress);
-        Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress);
+        heap.checkAndMarkPointer(&visitor, largeObjectAddress);
+        heap.checkAndMarkPointer(&visitor, largeObjectEndAddress);
         EXPECT_EQ(0ul, visitor.count());
     }
     // This round of GC is important to make sure that the object start
     // bitmap are cleared out and that the free lists are rebuild.
     clearOutOldGarbage();
 }
 
 TEST(HeapTest, PersistentHeapCollectionTypes)
 {
     IntWrapper::s_destructorCalls = 0;
@@ skipping 900 matching lines @@
     static void sleeperMainFunc()
     {
         ThreadState::attach();
         s_sleeperRunning = true;
 
         // Simulate a long running op that is not entering a safepoint.
         while (!s_sleeperDone) {
             testing::yieldCurrentThread();
         }
 
-        ThreadState::detach();
+        ThreadState::detachCurrentThread();
         s_sleeperRunning = false;
     }
 
     static volatile bool s_sleeperRunning;
     static volatile bool s_sleeperDone;
 };
 
 volatile bool GCParkingThreadTester::s_sleeperRunning = false;
 volatile bool GCParkingThreadTester::s_sleeperDone = false;
 
@@ skipping 257 matching lines @@
 
 // These special traits will remove a set from a map when the set is empty.
 struct EmptyClearingHashSetTraits : HashTraits<WeakSet> {
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     template<typename VisitorDispatcher>
     static bool traceInCollection(VisitorDispatcher visitor, WeakSet& set, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         bool liveEntriesFound = false;
         WeakSet::iterator end = set.end();
         for (WeakSet::iterator it = set.begin(); it != end; ++it) {
-            if (Heap::isHeapObjectAlive(*it)) {
+            if (ThreadHeap::isHeapObjectAlive(*it)) {
                 liveEntriesFound = true;
                 break;
             }
         }
         // If there are live entries in the set then the set cannot be removed
         // from the map it is contained in, and we need to mark it (and its
         // backing) live. We just trace normally, which will invoke the normal
         // weak handling for any entries that are not live.
         if (liveEntriesFound)
             set.trace(visitor);
@@ skipping 412 matching lines @@
 
         // 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.
         parkWorkerThread();
 
-        ThreadState::detach();
+        ThreadState::detachCurrentThread();
     }
 
     static volatile uintptr_t s_workerObjectPointer;
 };
 
 volatile uintptr_t DeadBitTester::s_workerObjectPointer = 0;
 
 TEST(HeapTest, ObjectDeadBit)
 {
     DeadBitTester::test();
@@ skipping 92 matching lines @@
                 EXPECT_EQ(32, it->value->value());
             }
 
             // Disregarding the iterator but keeping the collection alive
             // with a persistent should lead to weak processing.
             preciselyCollectGarbage();
             EXPECT_EQ(0u, collection->size());
         }
 
         wakeMainThread();
-        ThreadState::detach();
+        ThreadState::detachCurrentThread();
     }
 
     static volatile uintptr_t s_workerObjectPointer;
 };
 
 TEST(HeapTest, ThreadedStrongification)
 {
     ThreadedStrongificationTester::test();
 }
 
@@ skipping 147 matching lines @@
         parkWorkerThread();
         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();
+        ThreadState::detachCurrentThread();
     }
 
     static volatile IntWrapper* s_workerObjectPointer;
 };
 
 TEST(HeapTest, RecursiveMutex)
 {
     RecursiveLockingTester::test();
 }
 
@@ skipping 193 matching lines @@
     {
     }
 };
 
 // Regression test for crbug.com/404511. Tests conservative marking of
 // an object with an uninitialized vtable.
 TEST(HeapTest, AllocationInSuperConstructorArgument)
 {
     AllocInSuperConstructorArgument* object = new AllocInSuperConstructorArgument();
     EXPECT_TRUE(object);
-    Heap::collectAllGarbage();
+    ThreadHeap::collectAllGarbage();
 }
 
 class NonNodeAllocatingNodeInDestructor : public GarbageCollectedFinalized<NonNodeAllocatingNodeInDestructor> {
 public:
     ~NonNodeAllocatingNodeInDestructor()
     {
         s_node = new Persistent<IntNode>(IntNode::create(10));
     }
 
     DEFINE_INLINE_TRACE() { }
@@ skipping 431 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(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
-    ThreadState::detach();
+    ThreadState::detachCurrentThread();
     wakeMainThread();
 }
 
 } // anonymous namespace
 
 TEST(HeapTest, CrossThreadWeakPersistent)
 {
     // Create an object in the worker thread, have a CrossThreadWeakPersistent pointing to it on the main thread,
     // clear the reference in the worker thread, run a GC in the worker thread, and see if the
     // CrossThreadWeakPersistent is cleared.
@@ skipping 58 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