Oilpan: Replace Heap::collectGarbage(...) with a helper function

Source/platform/heap/HeapTest.cpp

Index: Source/platform/heap/HeapTest.cpp
diff --git a/Source/platform/heap/HeapTest.cpp b/Source/platform/heap/HeapTest.cpp
index 41beeb9f9fd9bcd6e70851161f4fc78808a0a143..297a3c1bf480e0adcb933d32987dedfadd9783b7 100644
--- a/Source/platform/heap/HeapTest.cpp
+++ b/Source/platform/heap/HeapTest.cpp
@@ -48,6 +48,16 @@
 
 namespace blink {
 
+static void preciselyCollectGarbage()
+{
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+}
+
+static void conservativelyCollectGarbage()
+{
+    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+}
+
 class IntWrapper : public GarbageCollectedFinalized<IntWrapper> {
 public:
     static IntWrapper* create(int x)
@@ -410,7 +420,7 @@ static void clearOutOldGarbage()
 {
     while (true) {
         size_t used = Heap::objectPayloadSizeForTesting();
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         if (Heap::objectPayloadSizeForTesting() >= used)
             break;
     }
@@ -530,7 +540,7 @@ protected:
                 }
 
                 if (gcCount < gcPerThread) {
-                    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                    preciselyCollectGarbage();
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
@@ -539,7 +549,7 @@ protected:
                 // 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(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                preciselyCollectGarbage();
                 EXPECT_EQ(wrapper->value(), 0x0bbac0de);
                 EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
             }
@@ -585,7 +595,7 @@ private:
                 }
 
                 if (gcCount < gcPerThread) {
-                    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                    preciselyCollectGarbage();
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
@@ -594,7 +604,7 @@ private:
                 // 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(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                preciselyCollectGarbage();
                 EXPECT_TRUE(weakMap->isEmpty());
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
@@ -1406,7 +1416,7 @@ public:
     void doStuff(PassRefPtrWillBeRawPtr<SuperClass> targetPass, PointsBack* pointsBack, int superClassCount)
     {
         RefPtrWillBeRawPtr<SuperClass> target = targetPass;
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(pointsBack, target->pointsBack());
         EXPECT_EQ(superClassCount, SuperClass::s_aliveCount);
     }
@@ -1684,10 +1694,10 @@ TEST(HeapTest, Transition)
     {
         RefPtrWillBePersistent<TransitionRefCounted> refCounted = TransitionRefCounted::create();
         EXPECT_EQ(1, TransitionRefCounted::s_aliveCount);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(1, TransitionRefCounted::s_aliveCount);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0, TransitionRefCounted::s_aliveCount);
 
     RefPtrWillBePersistent<PointsBack> pointsBack1 = PointsBack::create();
@@ -1699,7 +1709,7 @@ TEST(HeapTest, Transition)
     EXPECT_EQ(1, SubClass::s_aliveCount);
     EXPECT_EQ(1, SubData::s_aliveCount);
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0, TransitionRefCounted::s_aliveCount);
     EXPECT_EQ(2, PointsBack::s_aliveCount);
     EXPECT_EQ(2, SuperClass::s_aliveCount);
@@ -1707,7 +1717,7 @@ TEST(HeapTest, Transition)
     EXPECT_EQ(1, SubData::s_aliveCount);
 
     superClass->doStuff(superClass.release(), pointsBack1.get(), 2);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, PointsBack::s_aliveCount);
     EXPECT_EQ(1, SuperClass::s_aliveCount);
     EXPECT_EQ(1, SubClass::s_aliveCount);
@@ -1715,14 +1725,14 @@ TEST(HeapTest, Transition)
     EXPECT_EQ(0, pointsBack1->backPointer());
 
     pointsBack1.release();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, PointsBack::s_aliveCount);
     EXPECT_EQ(1, SuperClass::s_aliveCount);
     EXPECT_EQ(1, SubClass::s_aliveCount);
     EXPECT_EQ(1, SubData::s_aliveCount);
 
     subClass->doStuff(subClass.release(), pointsBack2.get(), 1);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, PointsBack::s_aliveCount);
     EXPECT_EQ(0, SuperClass::s_aliveCount);
     EXPECT_EQ(0, SubClass::s_aliveCount);
@@ -1730,7 +1740,7 @@ TEST(HeapTest, Transition)
     EXPECT_EQ(0, pointsBack2->backPointer());
 
     pointsBack2.release();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0, PointsBack::s_aliveCount);
     EXPECT_EQ(0, SuperClass::s_aliveCount);
     EXPECT_EQ(0, SubClass::s_aliveCount);
@@ -1787,7 +1797,7 @@ TEST(HeapTest, BasicFunctionality)
         EXPECT_EQ(alloc64->get(0), 27);
         EXPECT_EQ(alloc64->get(63), 27);
 
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
 
         EXPECT_EQ(alloc32->get(0), 40);
         EXPECT_EQ(alloc32->get(31), 40);
@@ -1898,13 +1908,13 @@ TEST(HeapTest, SimplePersistent)
     Persistent<TraceCounter> traceCounter = TraceCounter::create();
     EXPECT_EQ(0, traceCounter->traceCount());
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, traceCounter->traceCount());
 
     Persistent<ClassWithMember> classWithMember = ClassWithMember::create();
     EXPECT_EQ(0, classWithMember->traceCount());
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, classWithMember->traceCount());
     EXPECT_EQ(2, traceCounter->traceCount());
 }
@@ -1914,11 +1924,11 @@ TEST(HeapTest, SimpleFinalization)
     {
         Persistent<SimpleFinalizedObject> finalized = SimpleFinalizedObject::create();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, SimpleFinalizedObject::s_destructorCalls);
 }
 
@@ -1930,7 +1940,7 @@ TEST(HeapTest, FreelistReuse)
     for (int i = 0; i < 100; i++)
         new IntWrapper(i);
     IntWrapper* p1 = new IntWrapper(100);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // In non-production builds, we delay reusing freed memory for at least
     // one GC cycle.
     for (int i = 0; i < 100; i++) {
@@ -1938,8 +1948,8 @@ TEST(HeapTest, FreelistReuse)
         EXPECT_NE(p1, p2);
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
+    preciselyCollectGarbage();
     // Now the freed memory in the first GC should be reused.
     bool reusedMemoryFound = false;
     for (int i = 0; i < 10000; i++) {
@@ -1967,7 +1977,7 @@ TEST(HeapTest, LazySweepingPages)
     for (int i = 0; i < 10000; i++)
         SimpleFinalizedObject::create();
     EXPECT_EQ(1000, SimpleFinalizedObject::s_destructorCalls);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(11000, SimpleFinalizedObject::s_destructorCalls);
 }
 
@@ -1982,8 +1992,8 @@ TEST(HeapTest, LazySweepingLargeObjectPages)
         new IntWrapper(i);
     }
     Persistent<IntWrapper> p2 = new IntWrapper(2);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
+    preciselyCollectGarbage();
 
     LargeHeapObject::s_destructorCalls = 0;
     EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
@@ -2000,7 +2010,7 @@ TEST(HeapTest, LazySweepingLargeObjectPages)
     EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(22, LargeHeapObject::s_destructorCalls);
 }
 
@@ -2093,11 +2103,11 @@ TEST(HeapTest, Finalization)
     }
     // Nothing is marked so the GC should free everything and call
     // the finalizer on all three objects.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, HeapTestSubClass::s_destructorCalls);
     EXPECT_EQ(3, HeapTestSuperClass::s_destructorCalls);
     // Destructors not called again when GCing again.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, HeapTestSubClass::s_destructorCalls);
     EXPECT_EQ(3, HeapTestSuperClass::s_destructorCalls);
 }
@@ -2131,19 +2141,19 @@ TEST(HeapTest, Members)
         Persistent<Baz> h2;
         {
             h1 = Baz::create(Bar::create());
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(1u, Bar::s_live);
             h2 = Baz::create(Bar::create());
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(2u, Bar::s_live);
         }
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(2u, Bar::s_live);
         h1->clear();
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(1u, Bar::s_live);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
 }
 
@@ -2159,14 +2169,14 @@ TEST(HeapTest, MarkTest)
             ASSERT(ThreadState::current()->findPageFromAddress(foo));
             EXPECT_EQ(2u, Bar::s_live);
             EXPECT_TRUE(reinterpret_cast<Address>(foo) != reinterpret_cast<Address>(bar.get()));
-            Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            conservativelyCollectGarbage();
             EXPECT_TRUE(foo != bar); // To make sure foo is kept alive.
             EXPECT_EQ(2u, Bar::s_live);
         }
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(1u, Bar::s_live);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
 }
 
@@ -2186,11 +2196,11 @@ TEST(HeapTest, DeepTest)
             ASSERT(ThreadState::current()->findPageFromAddress(foo));
         }
         EXPECT_EQ(depth + 2, Bar::s_live);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(foo != bar); // To make sure foo and bar are kept alive.
         EXPECT_EQ(depth + 2, Bar::s_live);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
 }
 
@@ -2201,14 +2211,14 @@ TEST(HeapTest, WideTest)
         Bars* bars = Bars::create();
         unsigned width = Bars::width;
         EXPECT_EQ(width + 1, Bar::s_live);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(width + 1, Bar::s_live);
         // Use bars here to make sure that it will be on the stack
         // for the conservative stack scan to find.
         EXPECT_EQ(width, bars->getWidth());
     }
     EXPECT_EQ(Bars::width + 1, Bar::s_live);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
 }
 
@@ -2232,7 +2242,7 @@ TEST(HeapTest, HashMapOfMembers)
         size_t afterSetWasCreated = Heap::objectPayloadSizeForTesting();
         EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         size_t afterGC = Heap::objectPayloadSizeForTesting();
         EXPECT_EQ(afterGC, afterSetWasCreated);
 
@@ -2259,13 +2269,13 @@ TEST(HeapTest, HashMapOfMembers)
         // backing store. We make sure to not use conservative
         // stack scanning as that could find a pointer to the
         // old backing.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         size_t afterAddAndGC = Heap::objectPayloadSizeForTesting();
         EXPECT_TRUE(afterAddAndGC >= afterOneAdd);
 
         EXPECT_EQ(map->size(), 2u); // Two different wrappings of '1' are distinct.
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_TRUE(map->contains(one));
         EXPECT_TRUE(map->contains(anotherOne));
 
@@ -2292,12 +2302,12 @@ TEST(HeapTest, HashMapOfMembers)
         EXPECT_EQ(gross->value(), 144);
 
         // This should clear out any junk backings created by all the adds.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         size_t afterGC3 = Heap::objectPayloadSizeForTesting();
         EXPECT_TRUE(afterGC3 <= afterAdding1000);
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The objects 'one', anotherOne, and the 999 other pairs.
     EXPECT_EQ(IntWrapper::s_destructorCalls, 2000);
     size_t afterGC4 = Heap::objectPayloadSizeForTesting();
@@ -2369,7 +2379,7 @@ TEST(HeapTest, LargeHeapObjects)
     EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeHeapObject::s_destructorCalls);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 }
 
 typedef std::pair<Member<IntWrapper>, int> PairWrappedUnwrapped;
@@ -2446,20 +2456,20 @@ TEST(HeapTest, HeapVectorWithInlineCapacity)
         HeapVector<Member<IntWrapper>, 2> vector;
         vector.append(one);
         vector.append(two);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(vector.contains(one));
         EXPECT_TRUE(vector.contains(two));
 
         vector.append(three);
         vector.append(four);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(vector.contains(one));
         EXPECT_TRUE(vector.contains(two));
         EXPECT_TRUE(vector.contains(three));
         EXPECT_TRUE(vector.contains(four));
 
         vector.shrink(1);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(vector.contains(one));
         EXPECT_FALSE(vector.contains(two));
         EXPECT_FALSE(vector.contains(three));
@@ -2472,7 +2482,7 @@ TEST(HeapTest, HeapVectorWithInlineCapacity)
         vector1.append(one);
         vector2.append(two);
         vector1.swap(vector2);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(vector1.contains(two));
         EXPECT_TRUE(vector2.contains(one));
     }
@@ -2487,7 +2497,7 @@ TEST(HeapTest, HeapVectorWithInlineCapacity)
         vector2.append(five);
         vector2.append(six);
         vector1.swap(vector2);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_TRUE(vector1.contains(three));
         EXPECT_TRUE(vector1.contains(four));
         EXPECT_TRUE(vector1.contains(five));
@@ -2680,7 +2690,7 @@ TEST(HeapTest, HeapCollectionTypes)
 
             // Collect garbage. This should change nothing since we are keeping
             // alive the IntWrapper objects with on-stack pointers.
-            Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            conservativelyCollectGarbage();
 
             EXPECT_TRUE(dequeContains(*deque, oneB));
 
@@ -2802,7 +2812,7 @@ TEST(HeapTest, HeapCollectionTypes)
             EXPECT_FALSE(dequeContains(*dequeUW2, PairUnwrappedWrapped(103, &*threeF)));
         }
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
 
         EXPECT_EQ(4u, memberMember->size());
         EXPECT_EQ(0u, memberMember2->size());
@@ -2836,8 +2846,8 @@ TEST(HeapTest, HeapCollectionTypes)
         EXPECT_EQ(3, deque->begin()->get()->value());
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
+    preciselyCollectGarbage();
 
     EXPECT_EQ(4u, memberMember->size());
     EXPECT_EQ(4u, primitiveMember->size());
@@ -2968,7 +2978,7 @@ TEST(HeapTest, HeapWeakCollectionSimple)
 
     keepNumbersAlive[0] = nullptr;
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(0u, weakStrong->size());
     EXPECT_EQ(0u, strongWeak->size());
@@ -3068,7 +3078,7 @@ void orderedSetHelper(bool strong)
 
     keepNumbersAlive[0] = nullptr;
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(2u + (strong ? 1u : 0u), set1->size());
 
@@ -3157,8 +3167,8 @@ static void heapMapDestructorHelper(bool clearMaps)
         Map stackMap;
         RefMap stackRefMap;
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
+        preciselyCollectGarbage();
 
         stackMap.add(IntWrapper::create(42), ThingWithDestructor(1729));
         stackMap.add(luck, ThingWithDestructor(8128));
@@ -3175,8 +3185,8 @@ static void heapMapDestructorHelper(bool clearMaps)
 
     // The RefCountedAndGarbageCollected things need an extra GC to discover
     // that they are no longer ref counted.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
+    preciselyCollectGarbage();
     EXPECT_EQ(baseLine - 2, ThingWithDestructor::s_liveThingsWithDestructor);
     EXPECT_EQ(refBaseLine + 2, RefCountedAndGarbageCollected::s_destructorCalls);
 
@@ -3198,15 +3208,15 @@ static void heapMapDestructorHelper(bool clearMaps)
     } else {
         map.clear(); // Clear Persistent handle, not map.
         refMap.clear(); // Clear Persistent handle, not map.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
+        preciselyCollectGarbage();
     }
 
     EXPECT_EQ(baseLine - 2, ThingWithDestructor::s_liveThingsWithDestructor);
 
     // Need a GC to make sure that the RefCountedAndGarbageCollected thing
     // noticies it's been decremented to zero.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(refBaseLine + 2, RefCountedAndGarbageCollected::s_destructorCalls);
 }
 
@@ -3325,7 +3335,7 @@ void weakPairsHelper()
 
     checkPairSets<WSSet, SWSet, WUSet, UWSet>(weakStrong, strongWeak, weakUnwrapped, unwrappedWeak, true, two);
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     checkPairSets<WSSet, SWSet, WUSet, UWSet>(weakStrong, strongWeak, weakUnwrapped, unwrappedWeak, false, two);
 }
 
@@ -3417,7 +3427,7 @@ TEST(HeapTest, HeapWeakCollectionTypes)
 
             // Collect garbage. This should change nothing since we are keeping
             // alive the IntWrapper objects.
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
 
             EXPECT_EQ(64u, weakStrong->size());
             EXPECT_EQ(64u, strongWeak->size());
@@ -3457,7 +3467,7 @@ TEST(HeapTest, HeapWeakCollectionTypes)
                 WeakOrderedSet::iterator it5 = weakOrderedSet->begin();
                 // Collect garbage. This should change nothing since the
                 // iterators make the collections strong.
-                Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                conservativelyCollectGarbage();
                 if (collectionNumber == weakStrongIndex) {
                     EXPECT_EQ(64u, weakStrong->size());
                     MapIteratorCheck(it1, weakStrong->end(), 64);
@@ -3477,7 +3487,7 @@ TEST(HeapTest, HeapWeakCollectionTypes)
             } else {
                 // Collect garbage. This causes weak processing to remove
                 // things from the collections.
-                Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                preciselyCollectGarbage();
                 unsigned count = 0;
                 for (int i = 0; i < 128; i += 2) {
                     bool firstAlive = keepNumbersAlive[i];
@@ -3545,7 +3555,7 @@ TEST(HeapTest, HeapWeakCollectionTypes)
             }
             for (unsigned i = 0; i < 128 + added; i++)
                 keepNumbersAlive[i] = nullptr;
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(0u, weakStrong->size());
             EXPECT_EQ(0u, strongWeak->size());
             EXPECT_EQ(0u, weakWeak->size());
@@ -3565,24 +3575,24 @@ TEST(HeapTest, RefCountedGarbageCollected)
             {
                 Persistent<RefCountedAndGarbageCollected> refPtr1 = RefCountedAndGarbageCollected::create();
                 Persistent<RefCountedAndGarbageCollected> refPtr2 = RefCountedAndGarbageCollected::create();
-                Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                preciselyCollectGarbage();
                 EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
                 persistent = refPtr1.get();
             }
             // Reference count is zero for both objects but one of
             // them is kept alive by a persistent handle.
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
             refPtr3 = persistent.get();
         }
         // The persistent handle is gone but the ref count has been
         // increased to 1.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
     }
     // Both persistent handle is gone and ref count is zero so the
     // object can be collected.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, RefCountedAndGarbageCollected::s_destructorCalls);
 }
 
@@ -3603,11 +3613,11 @@ TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
-            Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            conservativelyCollectGarbage();
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
         EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
@@ -3626,17 +3636,17 @@ TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
-            Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            conservativelyCollectGarbage();
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
 
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
         EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(1, RefCountedAndGarbageCollected2::s_destructorCalls);
 }
@@ -3648,14 +3658,14 @@ TEST(HeapTest, WeakMembers)
         Persistent<Bar> h1 = Bar::create();
         Persistent<Weak> h4;
         Persistent<WithWeakMember> h5;
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         ASSERT_EQ(1u, Bar::s_live); // h1 is live.
         {
             Bar* h2 = Bar::create();
             Bar* h3 = Bar::create();
             h4 = Weak::create(h2, h3);
             h5 = WithWeakMember::create(h2, h3);
-            Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            conservativelyCollectGarbage();
             EXPECT_EQ(5u, Bar::s_live); // The on-stack pointer keeps h3 alive.
             EXPECT_FALSE(h3->hasBeenFinalized());
             EXPECT_TRUE(h4->strongIsThere());
@@ -3664,20 +3674,20 @@ TEST(HeapTest, WeakMembers)
             EXPECT_TRUE(h5->weakIsThere());
         }
         // h3 is collected, weak pointers from h4 and h5 don't keep it alive.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(4u, Bar::s_live);
         EXPECT_TRUE(h4->strongIsThere());
         EXPECT_FALSE(h4->weakIsThere()); // h3 is gone from weak pointer.
         EXPECT_TRUE(h5->strongIsThere());
         EXPECT_FALSE(h5->weakIsThere()); // h3 is gone from weak pointer.
         h1.release(); // Zero out h1.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(3u, Bar::s_live); // Only h4, h5 and h2 are left.
         EXPECT_TRUE(h4->strongIsThere()); // h2 is still pointed to from h4.
         EXPECT_TRUE(h5->strongIsThere()); // h2 is still pointed to from h5.
     }
     // h4 and h5 have gone out of scope now and they were keeping h2 alive.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live); // All gone.
 }
 
@@ -3691,7 +3701,7 @@ TEST(HeapTest, FinalizationObserver)
     }
     // FinalizationObserver doesn't have a strong reference to |foo|. So |foo|
     // and its member will be collected.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
     EXPECT_TRUE(o->didCallWillFinalize());
 
@@ -3702,7 +3712,7 @@ TEST(HeapTest, FinalizationObserver)
     foo = 0;
     // FinalizationObserverWithHashMap doesn't have a strong reference to
     // |foo|. So |foo| and its member will be collected.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, Bar::s_live);
     EXPECT_EQ(0u, map.size());
     EXPECT_TRUE(FinalizationObserverWithHashMap::s_didCallWillFinalize);
@@ -3717,7 +3727,7 @@ TEST(HeapTest, PreFinalizer)
         Observable* foo = Observable::create(Bar::create());
         ThreadState::current()->registerPreFinalizer(foo);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(Observable::s_willFinalizeWasCalled);
 }
 
@@ -3729,7 +3739,7 @@ TEST(HeapTest, PreFinalizerIsNotCalledIfUnregistered)
         ThreadState::current()->registerPreFinalizer(foo);
         ThreadState::current()->unregisterPreFinalizer(foo);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_FALSE(Observable::s_willFinalizeWasCalled);
 }
 
@@ -3737,7 +3747,7 @@ TEST(HeapTest, PreFinalizerUnregistersItself)
 {
     ObservableWithPreFinalizer::s_disposeWasCalled = false;
     ObservableWithPreFinalizer::create();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(ObservableWithPreFinalizer::s_disposeWasCalled);
     // Don't crash, and assertions don't fail.
 }
@@ -3748,7 +3758,7 @@ TEST(HeapTest, NestedPreFinalizer)
     s_disposeWasCalledForPreFinalizerSubClass = false;
     s_disposeWasCalledForPreFinalizerMixin = false;
     PreFinalizerSubClass::create();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerBase);
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerSubClass);
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerMixin);
@@ -3889,7 +3899,7 @@ TEST(HeapTest, PersistentHeapCollectionTypes)
 
         // Collect |vec| and |one|.
         vec = 0;
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 
         EXPECT_EQ(2u, pVec.size());
@@ -3918,12 +3928,12 @@ TEST(HeapTest, PersistentHeapCollectionTypes)
         EXPECT_EQ(1u, wpMap.size());
         EXPECT_EQ(eleven, wpMap.get(ten));
         ten.clear();
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0u, wpMap.size());
     }
 
     // Collect previous roots.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
 }
 
@@ -3962,14 +3972,14 @@ TEST(HeapTest, CollectionNesting)
         map2->add(key + 1 + i, IntDeque());
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(1u, map2->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
     keepAlive = nullptr;
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 }
 
@@ -3979,17 +3989,17 @@ TEST(HeapTest, GarbageCollectedMixin)
 
     Persistent<UseMixin> usemixin = UseMixin::create();
     EXPECT_EQ(0, UseMixin::s_traceCount);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1, UseMixin::s_traceCount);
 
     Persistent<Mixin> mixin = usemixin;
     usemixin = nullptr;
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, UseMixin::s_traceCount);
 
     PersistentHeapHashSet<WeakMember<Mixin>> weakMap;
     weakMap.add(UseMixin::create());
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, weakMap.size());
 }
 
@@ -4010,7 +4020,7 @@ TEST(HeapTest, CollectionNesting2)
     EXPECT_EQ(1u, map->get(key).size());
 
     Persistent<HeapHashMap<void*, IntSet>> keepAlive(map);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
@@ -4039,7 +4049,7 @@ TEST(HeapTest, CollectionNesting3)
 
     Persistent<HeapVector<IntVector>> keepAlive(vector);
     Persistent<HeapDeque<IntDeque>> keepAlive2(deque);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1u, it->size());
     EXPECT_EQ(1u, it2->size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
@@ -4065,7 +4075,7 @@ TEST(HeapTest, EmbeddedInVector)
         vectorInheritedTrace.append(it1);
         vectorInheritedTrace.append(it2);
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
 
         // Since VectorObjectNoTrace has no trace method it will
@@ -4077,10 +4087,10 @@ TEST(HeapTest, EmbeddedInVector)
         VectorObjectNoTrace n1, n2;
         vectorNoTrace.append(n1);
         vectorNoTrace.append(n2);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(2, SimpleFinalizedObject::s_destructorCalls);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(8, SimpleFinalizedObject::s_destructorCalls);
 }
 
@@ -4104,7 +4114,7 @@ TEST(HeapTest, EmbeddedInDeque)
         dequeInheritedTrace.append(it1);
         dequeInheritedTrace.append(it2);
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
 
         // Since VectorObjectNoTrace has no trace method it will
@@ -4116,10 +4126,10 @@ TEST(HeapTest, EmbeddedInDeque)
         VectorObjectNoTrace n1, n2;
         dequeNoTrace.append(n1);
         dequeNoTrace.append(n2);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(2, SimpleFinalizedObject::s_destructorCalls);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(8, SimpleFinalizedObject::s_destructorCalls);
 }
 
@@ -4230,7 +4240,7 @@ TEST(HeapTest, VectorDestructors)
         vector.append(i1);
         vector.append(i2);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // This is not EXPECT_EQ but EXPECT_LE because a HeapVectorBacking calls
     // destructors for all elements in (not the size but) the capacity of
     // the vector. Thus the number of destructors called becomes larger
@@ -4244,7 +4254,7 @@ TEST(HeapTest, VectorDestructors)
         vector.append(i1);
         vector.append(i2); // This allocates an out-of-line buffer.
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
     InlinedVectorObject::s_destructorCalls = 0;
@@ -4254,16 +4264,16 @@ TEST(HeapTest, VectorDestructors)
         vector.append(i1);
         vector.append(i2);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
     InlinedVectorObject::s_destructorCalls = 0;
     {
         Persistent<InlinedVectorObjectWrapper> vectorWrapper = new InlinedVectorObjectWrapper();
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(2, InlinedVectorObject::s_destructorCalls);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_LE(8, InlinedVectorObject::s_destructorCalls);
 }
 
@@ -4280,7 +4290,7 @@ TEST(HeapTest, VectorDestructorsWithVtable)
         vector.append(i1);
         vector.append(i2);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
 
     InlinedVectorObjectWithVtable::s_destructorCalls = 0;
@@ -4290,7 +4300,7 @@ TEST(HeapTest, VectorDestructorsWithVtable)
         vector.append(i1);
         vector.append(i2); // This allocates an out-of-line buffer.
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(5, InlinedVectorObjectWithVtable::s_destructorCalls);
 
     InlinedVectorObjectWithVtable::s_destructorCalls = 0;
@@ -4300,16 +4310,16 @@ TEST(HeapTest, VectorDestructorsWithVtable)
         vector.append(i1);
         vector.append(i2);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
 
     InlinedVectorObjectWithVtable::s_destructorCalls = 0;
     {
         Persistent<InlinedVectorObjectWithVtableWrapper> vectorWrapper = new InlinedVectorObjectWithVtableWrapper();
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_EQ(3, InlinedVectorObjectWithVtable::s_destructorCalls);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(9, InlinedVectorObjectWithVtable::s_destructorCalls);
 }
 #endif
@@ -4352,7 +4362,7 @@ TEST(HeapTest, HeapTerminatedArray)
         arr = builder.release();
     }
 
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(prefixSize, arr->size());
     for (size_t i = 0; i < prefixSize; i++)
@@ -4366,7 +4376,7 @@ TEST(HeapTest, HeapTerminatedArray)
         arr = builder.release();
     }
 
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(prefixSize + suffixSize, arr->size());
     for (size_t i = 0; i < prefixSize + suffixSize; i++)
@@ -4375,7 +4385,7 @@ TEST(HeapTest, HeapTerminatedArray)
     {
         Persistent<HeapTerminatedArray<TerminatedArrayItem>> persistentArr = arr;
         arr = 0;
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         arr = persistentArr.get();
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
         EXPECT_EQ(prefixSize + suffixSize, arr->size());
@@ -4384,7 +4394,7 @@ TEST(HeapTest, HeapTerminatedArray)
     }
 
     arr = 0;
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(8, IntWrapper::s_destructorCalls);
 }
 
@@ -4400,7 +4410,7 @@ TEST(HeapTest, HeapLinkedStack)
     for (size_t i = 0; i < stackSize; i++)
         stack->push(TerminatedArrayItem(IntWrapper::create(i)));
 
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(stackSize, stack->size());
     while (!stack->isEmpty()) {
@@ -4410,7 +4420,7 @@ TEST(HeapTest, HeapLinkedStack)
 
     Persistent<HeapLinkedStack<TerminatedArrayItem>> pStack = stack;
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(stackSize, static_cast<size_t>(IntWrapper::s_destructorCalls));
     EXPECT_EQ(0u, pStack->size());
 }
@@ -4425,7 +4435,7 @@ TEST(HeapTest, AllocationDuringFinalization)
     Persistent<IntWrapper> wrapper;
     new FinalizationAllocator(&wrapper);
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(0, OneKiloByteObject::s_destructorCalls);
     EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
@@ -4434,7 +4444,7 @@ TEST(HeapTest, AllocationDuringFinalization)
     EXPECT_EQ(42, wrapper->value());
 
     wrapper.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The 42 IntWrappers were the ones allocated in ~FinalizationAllocator
     // and the ones allocated in LargeHeapObject.
     EXPECT_EQ(42, IntWrapper::s_destructorCalls);
@@ -4452,7 +4462,7 @@ TEST(HeapTest, AllocationDuringPrefinalizer)
     Persistent<IntWrapper> wrapper;
     new PreFinalizationAllocator(&wrapper);
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(0, OneKiloByteObject::s_destructorCalls);
     EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
@@ -4461,7 +4471,7 @@ TEST(HeapTest, AllocationDuringPrefinalizer)
     EXPECT_EQ(42, wrapper->value());
 
     wrapper.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The 42 IntWrappers were the ones allocated in the pre-finalizer
     // of PreFinalizationAllocator and the ones allocated in LargeHeapObject.
     EXPECT_EQ(42, IntWrapper::s_destructorCalls);
@@ -4510,14 +4520,14 @@ void destructorsCalledOnGC(bool addLots)
         }
 
         EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
     }
     // The destructors of the sets don't call the destructors of the elements
     // in the heap sets. You have to actually remove the elments, call clear()
     // or have a GC to get the destructors called.
     EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(RefCountedWithDestructor::s_wasDestructed);
 }
 
@@ -4611,15 +4621,15 @@ TEST(HeapTest, MultipleMixins)
     MultipleMixins* obj = new MultipleMixins();
     {
         Persistent<MixinA> a = obj;
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     }
     {
         Persistent<MixinB> b = obj;
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(3, IntWrapper::s_destructorCalls);
 }
 
@@ -4712,7 +4722,7 @@ void setWithCustomWeaknessHandling()
         set2.add(PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)));
         set3->add(PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)));
         set1->add(PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)));
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         // The first set is pointed to from a persistent, so it's referenced, but
         // the weak processing may have taken place.
         if (set1->size()) {
@@ -4733,7 +4743,7 @@ void setWithCustomWeaknessHandling()
             EXPECT_EQ(3, i3->second->value());
         }
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, set1->size());
     set1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt));
     set1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103))); // This one gets zapped at GC time because nothing holds the 103 alive.
@@ -4741,7 +4751,7 @@ void setWithCustomWeaknessHandling()
     set1->add(PairWithWeakHandling(livingInt, livingInt));
     set1->add(PairWithWeakHandling(livingInt, livingInt)); // This one is identical to the previous and doesn't add anything.
     EXPECT_EQ(4u, set1->size());
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2u, set1->size());
     Iterator i1 = set1->begin();
     EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
@@ -4774,7 +4784,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling)
         map1->add(PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)), OffHeapInt::create(1003));
         EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
 
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         // The first map2 is pointed to from a persistent, so it's referenced, but
         // the weak processing may have taken place.
         if (map1->size()) {
@@ -4798,7 +4808,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling)
             EXPECT_EQ(1002, i3->value->value());
         }
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(0u, map1->size());
     EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
@@ -4815,7 +4825,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling)
 
     EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
     EXPECT_EQ(4u, map1->size());
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
     EXPECT_EQ(2u, map1->size());
     Iterator i1 = map1->begin();
@@ -4844,7 +4854,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling2)
         map1->add(OffHeapInt::create(1003), PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)));
         EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
 
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         // The first map2 is pointed to from a persistent, so it's referenced, but
         // the weak processing may have taken place.
         if (map1->size()) {
@@ -4868,7 +4878,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling2)
             EXPECT_EQ(1002, i3->key->value());
         }
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(0u, map1->size());
     EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
@@ -4885,7 +4895,7 @@ TEST(HeapTest, MapWithCustomWeaknessHandling2)
 
     EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
     EXPECT_EQ(4u, map1->size());
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
     EXPECT_EQ(2u, map1->size());
     Iterator i1 = map1->begin();
@@ -4910,19 +4920,19 @@ TEST(HeapTest, RegressNullIsStrongified)
     Persistent<HeapHashMap<int, WeakMember<IntWrapper>>> map = new HeapHashMap<int, WeakMember<IntWrapper>>();
     addElementsToWeakMap(map);
     HeapHashMap<int, WeakMember<IntWrapper>>::AddResult result = map->add(800, nullptr);
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     result.storedValue->value = IntWrapper::create(42);
 }
 
 TEST(HeapTest, Bind)
 {
     OwnPtr<Closure> closure = bind(static_cast<void (Bar::*)(Visitor*)>(&Bar::trace), Bar::create(), static_cast<Visitor*>(0));
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The closure should have a persistent handle to the Bar.
     EXPECT_EQ(1u, Bar::s_live);
 
     OwnPtr<Closure> closure2 = bind(static_cast<void (Bar::*)(Visitor*)>(&Bar::trace), RawPtr<Bar>(Bar::create()), static_cast<Visitor*>(0));
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The closure should have a persistent handle to the Bar.
     EXPECT_EQ(2u, Bar::s_live);
     // RawPtr<OffHeapInt> should not make Persistent.
@@ -4931,7 +4941,7 @@ TEST(HeapTest, Bind)
     UseMixin::s_traceCount = 0;
     Mixin* mixin = UseMixin::create();
     OwnPtr<Closure> mixinClosure = bind(static_cast<void (Mixin::*)(Visitor*)>(&Mixin::trace), mixin, static_cast<Visitor*>(0));
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     // The closure should have a persistent handle to the mixin.
     EXPECT_EQ(1, UseMixin::s_traceCount);
 }
@@ -4996,7 +5006,7 @@ TEST(HeapTest, RemoveEmptySets)
     map->add(OffHeapInt::create(2), WeakSet());
     EXPECT_EQ(2u, map->size());
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1u, map->size()); // The one with key 2 was removed.
     EXPECT_EQ(1, OffHeapInt::s_destructorCalls);
     {
@@ -5005,7 +5015,7 @@ TEST(HeapTest, RemoveEmptySets)
     }
 
     livingInt.clear(); // The weak set can no longer keep the '42' alive now.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, map->size());
 }
 
@@ -5026,7 +5036,7 @@ TEST(HeapTest, EphemeronsInEphemerons)
                 one.clear();
             if (!keepInnerAlive)
                 two.clear();
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             if (keepOuterAlive) {
                 const InnerMap& inner = outer->get(one);
                 if (keepInnerAlive) {
@@ -5052,7 +5062,7 @@ TEST(HeapTest, EphemeronsInEphemerons)
                 newEntry.storedValue->value.add(composite, home);
             }
             composite.clear();
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(10000u, outer->size());
             for (int i = 0; i < 10000; i++) {
                 IntWrapper* value = keepAlive->at(i);
@@ -5060,7 +5070,7 @@ TEST(HeapTest, EphemeronsInEphemerons)
                 if (i & 1)
                     keepAlive->at(i) = nullptr;
             }
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(5000u, outer->size());
         }
     }
@@ -5096,7 +5106,7 @@ TEST(HeapTest, EphemeronsPointToEphemerons)
         chain->map().add(IntWrapper::create(103), new EphemeronWrapper());
     }
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EphemeronWrapper* wrapper = chain;
     for (int i = 0; i< 100; i++) {
@@ -5109,7 +5119,7 @@ TEST(HeapTest, EphemeronsPointToEphemerons)
     EXPECT_EQ(nullptr, wrapper);
 
     key2.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     wrapper = chain;
     for (int i = 0; i < 50; i++) {
@@ -5119,7 +5129,7 @@ TEST(HeapTest, EphemeronsPointToEphemerons)
     EXPECT_EQ(nullptr, wrapper);
 
     key.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, chain->map().size());
 }
 
@@ -5168,7 +5178,7 @@ TEST(HeapTest, Ephemeron)
     set->add(pw1);
     set->add(pw2);
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(2u, weakPairMap->size());
     EXPECT_EQ(2u, weakPairMap2->size());
@@ -5184,7 +5194,7 @@ TEST(HeapTest, Ephemeron)
     pw2.clear(); // Kills all entries in the pairWeakMaps except the first.
 
     for (int i = 0; i < 2; i++) {
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
 
         EXPECT_EQ(1u, weakPairMap->size());
         EXPECT_EQ(0u, weakPairMap2->size());
@@ -5200,7 +5210,7 @@ TEST(HeapTest, Ephemeron)
     wp1.clear();
     pw1.clear();
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(0u, weakPairMap->size());
     EXPECT_EQ(0u, pairWeakMap->size());
@@ -5231,16 +5241,16 @@ TEST(HeapTest, IndirectStrongToWeak)
     map->add(deadObject, new Link1(deadObject));
     map->add(lifeObject, new Link1(lifeObject));
     EXPECT_EQ(2u, map->size());
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(2u, map->size());
     EXPECT_EQ(deadObject, map->get(deadObject)->link());
     EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
     deadObject.clear(); // Now it can live up to its name.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(1u, map->size());
     EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
     lifeObject.clear(); // Despite its name.
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, map->size());
 }
 
@@ -5310,7 +5320,7 @@ public:
         // GC will not find it.
         // Also at this point the worker is waiting for the main thread
         // to be parked and will not do any sweep of its heap.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
 
         // Since the worker thread is not sweeping the worker object should
         // not have been finalized.
@@ -5323,7 +5333,7 @@ public:
         uintptr_t stackPtrValue = s_workerObjectPointer;
         s_workerObjectPointer = 0;
         ASSERT_UNUSED(stackPtrValue, stackPtrValue);
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
 
         // Since the worker thread is not sweeping the worker object should
         // not have been finalized.
@@ -5413,8 +5423,8 @@ public:
         // and mark unmarked objects dead. The collection on the worker
         // heap is found through the persistent and the backing should
         // be marked.
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
+        preciselyCollectGarbage();
 
         // Wake up the worker thread so it can continue. It will sweep
         // and perform another GC where the backing store of its
@@ -5479,7 +5489,7 @@ private:
             {
                 // Prevent weak processing with an iterator and GC.
                 WeakCollectionType::iterator it = collection->begin();
-                Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                conservativelyCollectGarbage();
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
@@ -5488,7 +5498,7 @@ private:
 
             // Disregarding the iterator but keeping the collection alive
             // with a persistent should lead to weak processing.
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(0u, collection->size());
         }
 
@@ -5506,7 +5516,7 @@ TEST(HeapTest, ThreadedStrongification)
 
 static bool allocateAndReturnBool()
 {
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     return true;
 }
 
@@ -5616,7 +5626,7 @@ public:
             // until the main thread has done its GC.
             wakeWorkerThread();
 
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
 
             // The worker thread should not have swept yet since it is waiting
             // to get the global mutex.
@@ -5801,7 +5811,7 @@ public:
 
     AllocatesOnAssignment(const AllocatesOnAssignment& other)
     {
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         m_value = new IntWrapper(other.m_value->value());
     }
 
@@ -5941,7 +5951,7 @@ Persistent<IntNode>* NonNodeAllocatingNodeInDestructor::s_node = 0;
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
@@ -6009,7 +6019,7 @@ TEST(HeapTest, TraceDeepEagerly)
         obj = new DeepEagerly(obj);
 
     Persistent<DeepEagerly> persistent(obj);
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     // Verify that the DeepEagerly chain isn't completely unravelled
     // by performing eager trace() calls, but the explicit mark
@@ -6324,7 +6334,7 @@ private:
         , m_traceCounter(TraceCounter::create())
     {
         ASSERT(!ThreadState::current()->isGCForbidden());
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         EXPECT_GT(member->traceCount(), 0);
         EXPECT_GT(traceCount(), 0);
     }
@@ -6354,10 +6364,10 @@ TEST(HeapTest, WeakPersistent)
 {
     Persistent<IntWrapper> object = new IntWrapper(20);
     OwnPtr<WeakPersistentHolder> holder = adoptPtr(new WeakPersistentHolder(object));
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(holder->object());
     object = nullptr;
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_FALSE(holder->object());
 }