Revert of Move collectGarbage* methods to ThreadState

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 34 matching lines @@
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 static void preciselyCollectGarbage()
 {
-    ThreadState::current()->collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
 }
 
 static void conservativelyCollectGarbage()
 {
-    ThreadState::current()->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 1944 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();
-    ThreadState::current()->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();
-    ThreadState::current()->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);
-    ThreadState::current()->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();
-    ThreadState::current()->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 4087 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);
-    ThreadState::current()->collectAllGarbage();
+    ThreadHeap::collectAllGarbage();
 }
 
 class NonNodeAllocatingNodeInDestructor : public GarbageCollectedFinalized<NonNodeAllocatingNodeInDestructor> {
 public:
     ~NonNodeAllocatingNodeInDestructor()
     {
         s_node = new Persistent<IntNode>(IntNode::create(10));
     }
 
     DEFINE_INLINE_TRACE() { }
@@ skipping 435 matching lines @@
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
     ThreadState::attachCurrentThread(false);
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();
 
     // Step 4: Run a GC.
-    ThreadState::current()->collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
     ThreadState::detachCurrentThread();
     wakeMainThread();
 }
 
 } // anonymous namespace
 
@@ skipping 271 matching lines @@
     static_assert(WTF::IsGarbageCollectedType<HeapLinkedHashSet<Member<IntWrapper>>>::value, "HeapLinkedHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapListHashSet<Member<IntWrapper>>>::value, "HeapListHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashCountedSet<Member<IntWrapper>>>::value, "HeapHashCountedSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashMap<int, Member<IntWrapper>>>::value, "HeapHashMap");
     static_assert(WTF::IsGarbageCollectedType<HeapVector<Member<IntWrapper>>>::value, "HeapVector");
     static_assert(WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value, "HeapDeque");
     static_assert(WTF::IsGarbageCollectedType<HeapTerminatedArray<Member<IntWrapper>>>::value, "HeapTerminatedArray");
 }
 
 } // namespace blink