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

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 "platform/heap/Visitor.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
 
 #include <gtest/gtest.h>
 
 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)
     {
         return new IntWrapper(x);
     }
 
     virtual ~IntWrapper()
     {
         ++s_destructorCalls;
@@ skipping 342 matching lines @@
     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()
 {
     while (true) {
         size_t used = Heap::objectPayloadSizeForTesting();
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         if (Heap::objectPayloadSizeForTesting() >= used)
             break;
     }
 }
 
 class OffHeapInt : public RefCounted<OffHeapInt> {
 public:
     static RefPtr<OffHeapInt> create(int x)
     {
         return adoptRef(new OffHeapInt(x));
@@ skipping 99 matching lines @@
                 for (int i = 0; i < numberOfAllocations; i++) {
                     wrapper = IntWrapper::create(0x0bbac0de);
                     if (!(i % 10)) {
                         globalPersistent = createGlobalPersistent(0x0ed0cabb);
                     }
                     SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
-                    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                    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(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);
             }
             SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             Platform::current()->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
@@ skipping 25 matching lines @@
                 PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     weakMap->add(static_cast<unsigned>(i), IntWrapper::create(0));
                     weakMap2.add(static_cast<unsigned>(i), IntWrapper::create(0));
                     SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
-                    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                    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(ThreadState::NoHeapPointersOnStack, ThreadState::TakeSnapshot, Heap::ForcedGC);
-                Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+                preciselyCollectGarbage();
                 EXPECT_TRUE(weakMap->isEmpty());
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
             SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
@@ skipping 791 matching lines @@
     {
 #if !ENABLE(OILPAN)
         m_pointsBack->setBackPointer(0);
 #endif
         --s_aliveCount;
     }
 
     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);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_pointsBack);
     }
 
     PointsBack* pointsBack() const { return m_pointsBack.get(); }
@@ skipping 257 matching lines @@
 
 private:
     Persistent<IntWrapper>* m_wrapper;
 };
 
 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();
     RefPtrWillBePersistent<PointsBack> pointsBack2 = PointsBack::create();
     RefPtrWillBePersistent<SuperClass> superClass = SuperClass::create(pointsBack1);
     RefPtrWillBePersistent<SubClass> subClass = SubClass::create(pointsBack2);
     EXPECT_EQ(2, PointsBack::s_aliveCount);
     EXPECT_EQ(2, SuperClass::s_aliveCount);
     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);
     EXPECT_EQ(1, SubClass::s_aliveCount);
     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);
     EXPECT_EQ(1, SubData::s_aliveCount);
     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);
     EXPECT_EQ(0, SubData::s_aliveCount);
     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);
     EXPECT_EQ(0, SubData::s_aliveCount);
 
     EXPECT_TRUE(superClass == subClass);
 }
 
 TEST(HeapTest, Threading)
 {
@@ skipping 36 matching lines @@
 
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
             EXPECT_EQ(Heap::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);
 
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        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;
@@ skipping 90 matching lines @@
     EXPECT_EQ(42, array->at(42));
     EXPECT_EQ(0, array->at(128));
     EXPECT_EQ(999 % 128, array->at(999));
 }
 
 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());
 }
 
 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);
 }
 
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
 TEST(HeapTest, FreelistReuse)
 {
     clearOutOldGarbage();
 
     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++) {
         IntWrapper* p2 = new IntWrapper(i);
         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++) {
         IntWrapper* p2 = new IntWrapper(i);
         if (p1 == p2) {
             reusedMemoryFound = true;
             break;
         }
     }
     EXPECT_TRUE(reusedMemoryFound);
 }
 #endif
 
 #if ENABLE(LAZY_SWEEPING)
 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(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::ForcedGC);
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     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);
 }
 
 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);
-    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);
     for (int i = 0; i < 10; i++)
         LargeHeapObject::create();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithoutSweep, Heap::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(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);
 }
 
 class SimpleFinalizedEagerObjectBase : public GarbageCollectedFinalized<SimpleFinalizedEagerObjectBase> {
 public:
     virtual ~SimpleFinalizedEagerObjectBase() { }
     DEFINE_INLINE_TRACE() { }
 
     EAGERLY_FINALIZE();
 protected:
@@ skipping 72 matching lines @@
         HeapTestSubClass* t1 = HeapTestSubClass::create();
         HeapTestSubClass* t2 = HeapTestSubClass::create();
         HeapTestSuperClass* t3 = HeapTestSuperClass::create();
         // FIXME(oilpan): Ignore unused variables.
         (void)t1;
         (void)t2;
         (void)t3;
     }
     // 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);
 }
 
 TEST(HeapTest, TypedHeapSanity)
 {
     // We use TraceCounter for allocating an object on the general heap.
     Persistent<TraceCounter> generalHeapObject = TraceCounter::create();
     Persistent<IntNode> typedHeapObject = IntNode::create(0);
     EXPECT_NE(pageFromObject(generalHeapObject.get()),
@@ skipping 13 matching lines @@
 }
 
 TEST(HeapTest, Members)
 {
     Bar::s_live = 0;
     {
         Persistent<Baz> h1;
         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);
 }
 
 TEST(HeapTest, MarkTest)
 {
     {
         Bar::s_live = 0;
         Persistent<Bar> bar = Bar::create();
         ASSERT(ThreadState::current()->findPageFromAddress(bar));
         EXPECT_EQ(1u, Bar::s_live);
         {
             Foo* foo = Foo::create(bar);
             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);
 }
 
 TEST(HeapTest, DeepTest)
 {
     const unsigned depth = 100000;
     Bar::s_live = 0;
     {
         Bar* bar = Bar::create();
         ASSERT(ThreadState::current()->findPageFromAddress(bar));
         Foo* foo = Foo::create(bar);
         ASSERT(ThreadState::current()->findPageFromAddress(foo));
         EXPECT_EQ(2u, Bar::s_live);
         for (unsigned i = 0; i < depth; i++) {
             Foo* foo2 = Foo::create(foo);
             foo = foo2;
             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);
 }
 
 TEST(HeapTest, WideTest)
 {
     Bar::s_live = 0;
     {
         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);
 }
 
 TEST(HeapTest, HashMapOfMembers)
 {
     IntWrapper::s_destructorCalls = 0;
 
     clearOutOldGarbage();
     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();
         EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
-        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        preciselyCollectGarbage();
         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();
         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.
-        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));
 
         IntWrapper* gotten(map->get(one));
         EXPECT_EQ(gotten->value(), one->value());
         EXPECT_EQ(gotten, one);
 
         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();
         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.
-        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();
     EXPECT_EQ(afterGC4, initialObjectPayloadSize);
 }
 
 TEST(HeapTest, NestedAllocation)
 {
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
@@ skipping 51 matching lines @@
         clearOutOldGarbage();
         EXPECT_TRUE(Heap::allocatedSpace() == afterAllocation);
         EXPECT_EQ(10, IntWrapper::s_destructorCalls);
         EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
     }
     clearOutOldGarbage();
     EXPECT_TRUE(initialObjectPayloadSize == Heap::objectPayloadSizeForTesting());
     EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
     EXPECT_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;
 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;
 typedef std::pair<int, WeakMember<IntWrapper>> PairUnwrappedWeak;
 
 class Container : public GarbageCollected<Container> {
@@ skipping 56 matching lines @@
     IntWrapper* one = IntWrapper::create(1);
     IntWrapper* two = IntWrapper::create(2);
     IntWrapper* three = IntWrapper::create(3);
     IntWrapper* four = IntWrapper::create(4);
     IntWrapper* five = IntWrapper::create(5);
     IntWrapper* six = IntWrapper::create(6);
     {
         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));
         EXPECT_FALSE(vector.contains(four));
     }
     {
         HeapVector<Member<IntWrapper>, 2> vector1;
         HeapVector<Member<IntWrapper>, 2> vector2;
 
         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));
     }
     {
         HeapVector<Member<IntWrapper>, 2> vector1;
         HeapVector<Member<IntWrapper>, 2> vector2;
 
         vector1.append(one);
         vector1.append(two);
         vector2.append(three);
         vector2.append(four);
         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));
         EXPECT_TRUE(vector1.contains(six));
         EXPECT_TRUE(vector2.contains(one));
         EXPECT_TRUE(vector2.contains(two));
     }
 }
 
 TEST(HeapTest, HeapVectorShrinkCapacity)
@@ skipping 172 matching lines @@
             vectorUW2->append(PairUnwrappedWrapped(105, &*fiveD));
             dequeUW->append(PairUnwrappedWrapped(1, &*oneF));
             dequeUW2->append(PairUnwrappedWrapped(103, &*threeF));
             dequeUW2->append(PairUnwrappedWrapped(104, &*fourF));
             dequeUW2->append(PairUnwrappedWrapped(105, &*fiveF));
 
             EXPECT_TRUE(dequeContains(*deque, oneB));
 
             // 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));
 
             EXPECT_EQ(0u, memberMember->size());
             EXPECT_EQ(4u, memberMember2->size());
             EXPECT_EQ(4u, primitiveMember->size());
             EXPECT_EQ(4u, memberPrimitive->size());
             EXPECT_EQ(1u, set->size());
             EXPECT_EQ(4u, set2->size());
             EXPECT_EQ(1u, set3->size());
@@ skipping 101 matching lines @@
             EXPECT_TRUE(dequeContains(*dequeWU, PairWrappedUnwrapped(&*fiveE, 45)));
             EXPECT_TRUE(dequeContains(*dequeWU2, PairWrappedUnwrapped(&*oneE, 42)));
             EXPECT_FALSE(dequeContains(*dequeWU2, PairWrappedUnwrapped(&*threeE, 43)));
             EXPECT_TRUE(dequeContains(*dequeUW, PairUnwrappedWrapped(103, &*threeF)));
             EXPECT_TRUE(dequeContains(*dequeUW, PairUnwrappedWrapped(104, &*fourF)));
             EXPECT_TRUE(dequeContains(*dequeUW, PairUnwrappedWrapped(105, &*fiveF)));
             EXPECT_TRUE(dequeContains(*dequeUW2, PairUnwrappedWrapped(1, &*oneF)));
             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());
         EXPECT_EQ(4u, primitiveMember->size());
         EXPECT_EQ(4u, memberPrimitive->size());
         EXPECT_EQ(4u, set->size());
         EXPECT_EQ(1u, set2->size());
         EXPECT_EQ(1u, set3->size());
         EXPECT_EQ(2u, vector->size());
         EXPECT_EQ(1u, vector2->size());
@@ skipping 13 matching lines @@
         EXPECT_TRUE(set->contains(two));
         EXPECT_FALSE(set->contains(oneB));
         EXPECT_TRUE(set2->contains(oneB));
         EXPECT_TRUE(set3->contains(oneB));
         EXPECT_EQ(2u, set3->find(oneB)->value);
         EXPECT_EQ(3, vector->at(0)->value());
         EXPECT_EQ(4, vector->at(1)->value());
         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());
     EXPECT_EQ(4u, memberPrimitive->size());
     EXPECT_EQ(4u, set->size());
     EXPECT_EQ(1u, set2->size());
     EXPECT_EQ(2u, vector->size());
     EXPECT_EQ(1u, vector2->size());
     EXPECT_EQ(3u, vectorWU->size());
     EXPECT_EQ(1u, vectorWU2->size());
@@ skipping 110 matching lines @@
         EXPECT_EQ(2u, weakWeak->size());
         EXPECT_EQ(4u, weakSet->size());
         EXPECT_EQ(4u, weakCountedSet->size());
         EXPECT_EQ(3u, weakCountedSet->find(two)->value);
         weakCountedSet->remove(two);
         EXPECT_EQ(2u, weakCountedSet->find(two)->value);
     }
 
     keepNumbersAlive[0] = 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());
     EXPECT_EQ(2u, weakSet->size());
     EXPECT_EQ(2u, weakCountedSet->size());
 }
 
 template<typename Set>
 void orderedSetHelper(bool strong)
@@ skipping 79 matching lines @@
     EXPECT_EQ(constSet.rend(), creverse);
 
     typename Set::iterator iX(set2->begin());
     EXPECT_EQ(set2->end(), iX);
 
     if (strong)
         set1->remove(keepNumbersAlive[0]);
 
     keepNumbersAlive[0] = nullptr;
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(2u + (strong ? 1u : 0u), set1->size());
 
     EXPECT_EQ(2 + (strong ? 0 : 1), IntWrapper::s_destructorCalls);
 
     typename Set::iterator i2(set1->begin());
     if (strong) {
         EXPECT_EQ(0, (*i2)->value());
         ++i2;
         EXPECT_NE(set1->end(), i2);
@@ skipping 68 matching lines @@
     Persistent<RefMap> refMap(new RefMap());
 
     Persistent<IntWrapper> luck(IntWrapper::create(103));
 
     int baseLine, refBaseLine;
 
     {
         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));
         stackRefMap.add(IntWrapper::create(42), RefCountedAndGarbageCollected::create());
         stackRefMap.add(luck, RefCountedAndGarbageCollected::create());
 
         baseLine = ThingWithDestructor::s_liveThingsWithDestructor;
         refBaseLine = RefCountedAndGarbageCollected::s_destructorCalls;
 
         // Although the heap maps are on-stack, we can't expect prompt
         // finalization of the elements, so when they go out of scope here we
         // will not necessarily have called the relevant destructors.
     }
 
     // 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);
 
     // Now use maps kept alive with persistents. Here we don't expect any
     // destructors to be called before there have been GCs.
 
     map->add(IntWrapper::create(42), ThingWithDestructor(1729));
     map->add(luck, ThingWithDestructor(8128));
     refMap->add(IntWrapper::create(42), RefCountedAndGarbageCollected::create());
     refMap->add(luck, RefCountedAndGarbageCollected::create());
 
     baseLine  =  ThingWithDestructor::s_liveThingsWithDestructor;
     refBaseLine = RefCountedAndGarbageCollected::s_destructorCalls;
 
     luck.clear();
     if (clearMaps) {
         map->clear(); // Clear map.
         refMap->clear(); // Clear map.
     } 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);
 }
 
 TEST(HeapTest, HeapMapDestructor)
 {
     heapMapDestructorHelper(true);
     heapMapDestructorHelper(false);
 }
 
 typedef HeapHashSet<PairWeakStrong> WeakStrongSet;
@@ skipping 98 matching lines @@
     weakStrong->add(PairWeakStrong(&*two, &*two));
     strongWeak->add(PairStrongWeak(&*two, IntWrapper::create(1)));
     strongWeak->add(PairStrongWeak(&*two, &*two));
     weakUnwrapped->add(PairWeakUnwrapped(IntWrapper::create(1), 2));
     weakUnwrapped->add(PairWeakUnwrapped(&*two, 2));
     unwrappedWeak->add(PairUnwrappedWeak(2, IntWrapper::create(1)));
     unwrappedWeak->add(PairUnwrappedWeak(2, &*two));
 
     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);
 }
 
 TEST(HeapTest, HeapWeakPairs)
 {
     {
         typedef HeapHashSet<PairWeakStrong> WeakStrongSet;
         typedef HeapHashSet<PairWeakUnwrapped> WeakUnwrappedSet;
         typedef HeapHashSet<PairStrongWeak> StrongWeakSet;
         typedef HeapHashSet<PairUnwrappedWeak> UnwrappedWeakSet;
@@ skipping 71 matching lines @@
             }
 
             EXPECT_EQ(64u, weakStrong->size());
             EXPECT_EQ(64u, strongWeak->size());
             EXPECT_EQ(64u, weakWeak->size());
             EXPECT_EQ(64u, weakSet->size());
             EXPECT_EQ(64u, weakOrderedSet->size());
 
             // 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());
             EXPECT_EQ(64u, weakWeak->size());
             EXPECT_EQ(64u, weakSet->size());
             EXPECT_EQ(64u, weakOrderedSet->size());
 
             for (int i = 0; i < 128; i += 2) {
                 IntWrapper* wrapped = keepNumbersAlive[i];
                 IntWrapper* wrapped2 = keepNumbersAlive[i + 1];
@@ skipping 19 matching lines @@
                 weakOrderedSet->clear();
 
             if (testThatIteratorsMakeStrong) {
                 WeakStrong::iterator it1 = weakStrong->begin();
                 StrongWeak::iterator it2 = strongWeak->begin();
                 WeakWeak::iterator it3 = weakWeak->begin();
                 WeakSet::iterator it4 = weakSet->begin();
                 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);
                 } else if (collectionNumber == strongWeakIndex) {
                     EXPECT_EQ(64u, strongWeak->size());
                     MapIteratorCheck(it2, strongWeak->end(), 64);
                 } else if (collectionNumber == weakWeakIndex) {
                     EXPECT_EQ(64u, weakWeak->size());
                     MapIteratorCheck(it3, weakWeak->end(), 64);
                 } else if (collectionNumber == weakSetIndex) {
                     EXPECT_EQ(64u, weakSet->size());
                     SetIteratorCheck(it4, weakSet->end(), 64);
                 } else if (collectionNumber == weakOrderedSetIndex) {
                     EXPECT_EQ(64u, weakOrderedSet->size());
                     SetIteratorCheck(it5, weakOrderedSet->end(), 64);
                 }
             } 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];
                     bool secondAlive = keepNumbersAlive[i + 1];
                     if (firstAlive && (collectionNumber == weakStrongIndex || collectionNumber == strongWeakIndex))
                         secondAlive = true;
                     if (firstAlive && secondAlive && collectionNumber < numberOfMapIndices) {
                         if (collectionNumber == weakStrongIndex) {
                             if (deleteAfterwards)
                                 EXPECT_EQ(i + 1, weakStrong->take(keepNumbersAlive[i])->value());
@@ skipping 47 matching lines @@
                 WeakSet::iterator it4 = weakSet->begin();
                 WeakOrderedSet::iterator it5 = weakOrderedSet->begin();
                 MapIteratorCheck(it1, weakStrong->end(), (collectionNumber == weakStrongIndex ? count : 0) + added);
                 MapIteratorCheck(it2, strongWeak->end(), (collectionNumber == strongWeakIndex ? count : 0) + added);
                 MapIteratorCheck(it3, weakWeak->end(), (collectionNumber == weakWeakIndex ? count : 0) + added);
                 SetIteratorCheck(it4, weakSet->end(), (collectionNumber == weakSetIndex ? count : 0) + added);
                 SetIteratorCheck(it5, weakOrderedSet->end(), (collectionNumber == weakOrderedSetIndex ? count : 0) + added);
             }
             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());
             EXPECT_EQ(0u, weakSet->size());
             EXPECT_EQ(0u, weakOrderedSet->size());
         }
     }
 }
 
 TEST(HeapTest, RefCountedGarbageCollected)
 {
     RefCountedAndGarbageCollected::s_destructorCalls = 0;
     {
         RefPtr<RefCountedAndGarbageCollected> refPtr3;
         {
             Persistent<RefCountedAndGarbageCollected> persistent;
             {
                 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);
 }
 
 TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
 {
     RefCountedAndGarbageCollected::s_destructorCalls = 0;
     RefCountedAndGarbageCollected2::s_destructorCalls = 0;
     {
         RefCountedAndGarbageCollected* pointer1 = 0;
         RefCountedAndGarbageCollected2* pointer2 = 0;
         {
             Persistent<RefCountedAndGarbageCollected> object1 = RefCountedAndGarbageCollected::create();
             Persistent<RefCountedAndGarbageCollected2> object2 = RefCountedAndGarbageCollected2::create();
             pointer1 = object1.get();
             pointer2 = object2.get();
             void* objects[2] = { object1.get(), object2.get() };
             RefCountedGarbageCollectedVisitor visitor(2, objects);
             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);
 
         // At this point, the reference counts of object1 and object2 are 0.
         // Only pointer1 and pointer2 keep references to object1 and object2.
         void* objects[] = { 0 };
         RefCountedGarbageCollectedVisitor visitor(0, objects);
         ThreadState::current()->visitPersistents(&visitor);
         EXPECT_TRUE(visitor.validate());
 
         {
             Persistent<RefCountedAndGarbageCollected> object1(pointer1);
             Persistent<RefCountedAndGarbageCollected2> object2(pointer2);
             void* objects[2] = { object1.get(), object2.get() };
             RefCountedGarbageCollectedVisitor visitor(2, objects);
             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);
 }
 
 TEST(HeapTest, WeakMembers)
 {
     Bar::s_live = 0;
     {
         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());
             EXPECT_TRUE(h4->weakIsThere());
             EXPECT_TRUE(h5->strongIsThere());
             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.
 }
 
 TEST(HeapTest, FinalizationObserver)
 {
     Persistent<FinalizationObserver<Observable>> o;
     {
         Observable* foo = Observable::create(Bar::create());
         // |o| observes |foo|.
         o = FinalizationObserver<Observable>::create(foo);
     }
     // 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());
 
     FinalizationObserverWithHashMap::s_didCallWillFinalize = false;
     Observable* foo = Observable::create(Bar::create());
     FinalizationObserverWithHashMap::ObserverMap& map = FinalizationObserverWithHashMap::observe(*foo);
     EXPECT_EQ(1u, map.size());
     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);
 
     FinalizationObserverWithHashMap::clearObservers();
 }
 
 TEST(HeapTest, PreFinalizer)
 {
     Observable::s_willFinalizeWasCalled = false;
     {
         Observable* foo = Observable::create(Bar::create());
         ThreadState::current()->registerPreFinalizer(foo);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_TRUE(Observable::s_willFinalizeWasCalled);
 }
 
 TEST(HeapTest, PreFinalizerIsNotCalledIfUnregistered)
 {
     Observable::s_willFinalizeWasCalled = false;
     {
         Observable* foo = Observable::create(Bar::create());
         ThreadState::current()->registerPreFinalizer(foo);
         ThreadState::current()->unregisterPreFinalizer(foo);
     }
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_FALSE(Observable::s_willFinalizeWasCalled);
 }
 
 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.
 }
 
 TEST(HeapTest, NestedPreFinalizer)
 {
     s_disposeWasCalledForPreFinalizerBase = false;
     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);
     // Don't crash, and assertions don't fail.
 }
 
 TEST(HeapTest, Comparisons)
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
@@ skipping 120 matching lines @@
         pVec.append(three);
 
         pSet.add(four);
         pListSet.add(eight);
         pLinkedSet.add(nine);
         pMap.add(five, six);
         wpMap.add(ten, eleven);
 
         // 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());
         EXPECT_EQ(two, pVec.at(0));
         EXPECT_EQ(three, pVec.at(1));
 
         EXPECT_EQ(2u, pDeque.size());
         EXPECT_EQ(seven, pDeque.first());
         EXPECT_EQ(seven, pDeque.takeFirst());
         EXPECT_EQ(two, pDeque.first());
 
         EXPECT_EQ(1u, pDeque.size());
 
         EXPECT_EQ(1u, pSet.size());
         EXPECT_TRUE(pSet.contains(four));
 
         EXPECT_EQ(1u, pListSet.size());
         EXPECT_TRUE(pListSet.contains(eight));
 
         EXPECT_EQ(1u, pLinkedSet.size());
         EXPECT_TRUE(pLinkedSet.contains(nine));
 
         EXPECT_EQ(1u, pMap.size());
         EXPECT_EQ(six, pMap.get(five));
 
         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);
 }
 
 TEST(HeapTest, CollectionNesting)
 {
     clearOutOldGarbage();
     int* key = &IntWrapper::s_destructorCalls;
     IntWrapper::s_destructorCalls = 0;
     typedef HeapVector<Member<IntWrapper>> IntVector;
     typedef HeapDeque<Member<IntWrapper>> IntDeque;
@@ skipping 18 matching lines @@
     EXPECT_EQ(1u, map2->get(key).size());
 
     Persistent<HeapHashMap<void*, IntVector>> keepAlive(map);
     Persistent<HeapHashMap<void*, IntDeque>> keepAlive2(map2);
 
     for (int i = 0; i < 100; i++) {
         map->add(key + 1 + i, IntVector());
         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);
 }
 
 TEST(HeapTest, GarbageCollectedMixin)
 {
     clearOutOldGarbage();
 
     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());
 }
 
 TEST(HeapTest, CollectionNesting2)
 {
     clearOutOldGarbage();
     void* key = &IntWrapper::s_destructorCalls;
     IntWrapper::s_destructorCalls = 0;
     typedef HeapHashSet<Member<IntWrapper>> IntSet;
     HeapHashMap<void*, IntSet>* map = new HeapHashMap<void*, IntSet>();
 
     map->add(key, IntSet());
 
     HeapHashMap<void*, IntSet>::iterator it = map->find(key);
     EXPECT_EQ(0u, map->get(key).size());
 
     it->value.add(IntWrapper::create(42));
     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);
 }
 
 TEST(HeapTest, CollectionNesting3)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     typedef HeapVector<Member<IntWrapper>> IntVector;
     typedef HeapDeque<Member<IntWrapper>> IntDeque;
     HeapVector<IntVector>* vector = new HeapVector<IntVector>();
     HeapDeque<IntDeque>* deque = new HeapDeque<IntDeque>();
 
     vector->append(IntVector());
     deque->append(IntDeque());
 
     HeapVector<IntVector>::iterator it = vector->begin();
     HeapDeque<IntDeque>::iterator it2 = deque->begin();
     EXPECT_EQ(0u, it->size());
     EXPECT_EQ(0u, it2->size());
 
     it->append(IntWrapper::create(42));
     it2->append(IntWrapper::create(42));
     EXPECT_EQ(1u, it->size());
     EXPECT_EQ(1u, it2->size());
 
     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);
 }
 
 TEST(HeapTest, EmbeddedInVector)
 {
     clearOutOldGarbage();
     SimpleFinalizedObject::s_destructorCalls = 0;
     {
         PersistentHeapVector<VectorObject, 2> inlineVector;
         PersistentHeapVector<VectorObject> outlineVector;
         VectorObject i1, i2;
         inlineVector.append(i1);
         inlineVector.append(i2);
 
         VectorObject o1, o2;
         outlineVector.append(o1);
         outlineVector.append(o2);
 
         PersistentHeapVector<VectorObjectInheritedTrace> vectorInheritedTrace;
         VectorObjectInheritedTrace it1, it2;
         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
         // not be traced and hence be collected when doing GC.
         // We trace items in a collection braced on the item's
         // having a trace method. This is determined via the
         // NeedsTracing trait in wtf/TypeTraits.h.
         PersistentHeapVector<VectorObjectNoTrace> vectorNoTrace;
         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);
 }
 
 TEST(HeapTest, EmbeddedInDeque)
 {
     clearOutOldGarbage();
     SimpleFinalizedObject::s_destructorCalls = 0;
     {
         PersistentHeapDeque<VectorObject, 2> inlineDeque;
         PersistentHeapDeque<VectorObject> outlineDeque;
         VectorObject i1, i2;
         inlineDeque.append(i1);
         inlineDeque.append(i2);
 
         VectorObject o1, o2;
         outlineDeque.append(o1);
         outlineDeque.append(o2);
 
         PersistentHeapDeque<VectorObjectInheritedTrace> dequeInheritedTrace;
         VectorObjectInheritedTrace it1, it2;
         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
         // not be traced and hence be collected when doing GC.
         // We trace items in a collection braced on the item's
         // having a trace method. This is determined via the
         // NeedsTracing trait in wtf/TypeTraits.h.
         PersistentHeapDeque<VectorObjectNoTrace> dequeNoTrace;
         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);
 }
 
 class InlinedVectorObject {
     ALLOW_ONLY_INLINE_ALLOCATION();
 public:
     InlinedVectorObject()
     {
     }
     ~InlinedVectorObject()
@@ skipping 90 matching lines @@
 TEST(HeapTest, VectorDestructors)
 {
     clearOutOldGarbage();
     InlinedVectorObject::s_destructorCalls = 0;
     {
         HeapVector<InlinedVectorObject> vector;
         InlinedVectorObject i1, i2;
         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
     // than the actual number of objects in the vector.
     EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
     InlinedVectorObject::s_destructorCalls = 0;
     {
         HeapVector<InlinedVectorObject, 1> vector;
         InlinedVectorObject i1, i2;
         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;
     {
         HeapVector<InlinedVectorObject, 2> vector;
         InlinedVectorObject i1, i2;
         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);
 }
 
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, enable this test.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
 TEST(HeapTest, VectorDestructorsWithVtable)
 {
     clearOutOldGarbage();
     InlinedVectorObjectWithVtable::s_destructorCalls = 0;
     {
         HeapVector<InlinedVectorObjectWithVtable> vector;
         InlinedVectorObjectWithVtable i1, i2;
         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;
     {
         HeapVector<InlinedVectorObjectWithVtable, 1> vector;
         InlinedVectorObjectWithVtable i1, i2;
         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;
     {
         HeapVector<InlinedVectorObjectWithVtable, 2> vector;
         InlinedVectorObjectWithVtable i1, i2;
         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
 
 template<typename Set>
 void rawPtrInHashHelper()
 {
     Set set;
     set.add(new int(42));
     set.add(new int(42));
@@ skipping 22 matching lines @@
     const size_t suffixSize = 4;
 
     {
         HeapTerminatedArrayBuilder<TerminatedArrayItem> builder(arr);
         builder.grow(prefixSize);
         for (size_t i = 0; i < prefixSize; i++)
             builder.append(TerminatedArrayItem(IntWrapper::create(i)));
         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++)
         EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
 
     {
         HeapTerminatedArrayBuilder<TerminatedArrayItem> builder(arr);
         builder.grow(suffixSize);
         for (size_t i = 0; i < suffixSize; i++)
             builder.append(TerminatedArrayItem(IntWrapper::create(prefixSize + i)));
         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++)
         EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
 
     {
         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());
         for (size_t i = 0; i < prefixSize + suffixSize; i++)
             EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
     }
 
     arr = 0;
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(8, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, HeapLinkedStack)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
     HeapLinkedStack<TerminatedArrayItem>* stack = new HeapLinkedStack<TerminatedArrayItem>();
 
     const size_t stackSize = 10;
 
     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()) {
         EXPECT_EQ(stack->size() - 1, static_cast<size_t>(stack->peek().payload()->value()));
         stack->pop();
     }
 
     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());
 }
 
 TEST(HeapTest, AllocationDuringFinalization)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     OneKiloByteObject::s_destructorCalls = 0;
     LargeHeapObject::s_destructorCalls = 0;
 
     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);
     // Check that the wrapper allocated during finalization is not
     // swept away and zapped later in the same sweeping phase.
     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);
     EXPECT_EQ(512, OneKiloByteObject::s_destructorCalls);
     EXPECT_EQ(32, LargeHeapObject::s_destructorCalls);
 }
 
 TEST(HeapTest, AllocationDuringPrefinalizer)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     OneKiloByteObject::s_destructorCalls = 0;
     LargeHeapObject::s_destructorCalls = 0;
 
     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);
     // Check that the wrapper allocated during finalization is not
     // swept away and zapped later in the same sweeping phase.
     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);
     EXPECT_EQ(512, OneKiloByteObject::s_destructorCalls);
     EXPECT_EQ(32, LargeHeapObject::s_destructorCalls);
 }
 
 class SimpleClassWithDestructor {
 public:
     SimpleClassWithDestructor() { }
@@ skipping 28 matching lines @@
         set.add(adoptRef(hasDestructor));
         EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
 
         if (addLots) {
             for (int i = 0; i < 1000; i++) {
                 set.add(adoptRef(new RefCountedWithDestructor()));
             }
         }
 
         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);
 }
 
 template<typename Set>
 void destructorsCalledOnClear(bool addLots)
 {
     RefCountedWithDestructor::s_wasDestructed = false;
     Set set;
     RefCountedWithDestructor* hasDestructor = new RefCountedWithDestructor();
     set.add(adoptRef(hasDestructor));
@@ skipping 73 matching lines @@
 TEST(HeapTest, MultipleMixins)
 {
     EXPECT_TRUE(s_isMixinTrue);
     EXPECT_FALSE(s_isMixinFalse);
 
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     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);
 }
 
 class GCParkingThreadTester {
 public:
     static void test()
     {
         OwnPtr<WebThread> sleepingThread = adoptPtr(Platform::current()->createThread("SleepingThread"));
         sleepingThread->postTask(FROM_HERE, new Task(threadSafeBind(sleeperMainFunc)));
 
@@ skipping 72 matching lines @@
 {
     typedef typename Set::iterator Iterator;
     Persistent<IntWrapper> livingInt(IntWrapper::create(42));
     Persistent<Set> set1(new Set());
     {
         Set set2;
         Set* set3 = new Set();
         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()) {
             Iterator i1 = set1->begin();
             EXPECT_EQ(4, i1->first->value());
             EXPECT_EQ(5, i1->second->value());
         }
         // The second set is on-stack, so its backing store must be referenced from
         // the stack. That makes the weak references strong.
         Iterator i2 = set2.begin();
         EXPECT_EQ(0, i2->first->value());
         EXPECT_EQ(1, i2->second->value());
         // The third set is pointed to from the stack, so it's referenced, but the
         // weak processing may have taken place.
         if (set3->size()) {
             Iterator i3 = set3->begin();
             EXPECT_EQ(2, i3->first->value());
             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.
     set1->add(PairWithWeakHandling(IntWrapper::create(103), IntWrapper::create(103))); // This one gets zapped too.
     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);
     EXPECT_EQ(livingInt, i1->second);
     ++i1;
     EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
     EXPECT_EQ(livingInt, i1->second);
 }
 
 TEST(HeapTest, SetWithCustomWeaknessHandling)
@@ skipping 12 matching lines @@
     Persistent<Map> map1(new Map());
     Persistent<IntWrapper> livingInt(IntWrapper::create(42));
     {
         Map map2;
         Map* map3 = new Map();
         map2.add(PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)), OffHeapInt::create(1001));
         map3->add(PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)), OffHeapInt::create(1002));
         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()) {
             Iterator i1 = map1->begin();
             EXPECT_EQ(4, i1->key.first->value());
             EXPECT_EQ(5, i1->key.second->value());
             EXPECT_EQ(1003, i1->value->value());
         }
         // The second map2 is on-stack, so its backing store must be referenced from
         // the stack. That makes the weak references strong.
         Iterator i2 = map2.begin();
         EXPECT_EQ(0, i2->key.first->value());
         EXPECT_EQ(1, i2->key.second->value());
         EXPECT_EQ(1001, i2->value->value());
         // The third map2 is pointed to from the stack, so it's referenced, but the
         // weak processing may have taken place.
         if (map3->size()) {
             Iterator i3 = map3->begin();
             EXPECT_EQ(2, i3->key.first->value());
             EXPECT_EQ(3, i3->key.second->value());
             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);
 
     OffHeapInt::s_destructorCalls = 0;
 
     map1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt), OffHeapInt::create(2000));
     map1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103)), OffHeapInt::create(2001)); // This one gets zapped at GC time because nothing holds the 103 alive.
     map1->add(PairWithWeakHandling(IntWrapper::create(103), IntWrapper::create(103)), OffHeapInt::create(2002)); // This one gets zapped too.
     RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
     map1->add(PairWithWeakHandling(livingInt, livingInt), dupeInt);
     map1->add(PairWithWeakHandling(livingInt, livingInt), dupeInt); // This one is identical to the previous and doesn't add anything.
     dupeInt.clear();
 
     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();
     EXPECT_TRUE(i1->key.first->value() == 103 || i1->key.first == livingInt);
     EXPECT_EQ(livingInt, i1->key.second);
     ++i1;
     EXPECT_TRUE(i1->key.first->value() == 103 || i1->key.first == livingInt);
     EXPECT_EQ(livingInt, i1->key.second);
 }
 
 TEST(HeapTest, MapWithCustomWeaknessHandling2)
 {
     typedef HeapHashMap<RefPtr<OffHeapInt>, PairWithWeakHandling> Map;
     typedef Map::iterator Iterator;
     clearOutOldGarbage();
     OffHeapInt::s_destructorCalls = 0;
 
     Persistent<Map> map1(new Map());
     Persistent<IntWrapper> livingInt(IntWrapper::create(42));
 
     {
         Map map2;
         Map* map3 = new Map();
         map2.add(OffHeapInt::create(1001), PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)));
         map3->add(OffHeapInt::create(1002), PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)));
         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()) {
             Iterator i1 = map1->begin();
             EXPECT_EQ(4, i1->value.first->value());
             EXPECT_EQ(5, i1->value.second->value());
             EXPECT_EQ(1003, i1->key->value());
         }
         // The second map2 is on-stack, so its backing store must be referenced from
         // the stack. That makes the weak references strong.
         Iterator i2 = map2.begin();
         EXPECT_EQ(0, i2->value.first->value());
         EXPECT_EQ(1, i2->value.second->value());
         EXPECT_EQ(1001, i2->key->value());
         // The third map2 is pointed to from the stack, so it's referenced, but the
         // weak processing may have taken place.
         if (map3->size()) {
             Iterator i3 = map3->begin();
             EXPECT_EQ(2, i3->value.first->value());
             EXPECT_EQ(3, i3->value.second->value());
             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);
 
     OffHeapInt::s_destructorCalls = 0;
 
     map1->add(OffHeapInt::create(2000), PairWithWeakHandling(IntWrapper::create(103), livingInt));
     map1->add(OffHeapInt::create(2001), PairWithWeakHandling(livingInt, IntWrapper::create(103))); // This one gets zapped at GC time because nothing holds the 103 alive.
     map1->add(OffHeapInt::create(2002), PairWithWeakHandling(IntWrapper::create(103), IntWrapper::create(103))); // This one gets zapped too.
     RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
     map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt));
     map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt)); // This one is identical to the previous and doesn't add anything.
     dupeInt.clear();
 
     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();
     EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
     EXPECT_EQ(livingInt, i1->value.second);
     ++i1;
     EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
     EXPECT_EQ(livingInt, i1->value.second);
 }
 
 static void addElementsToWeakMap(HeapHashMap<int, WeakMember<IntWrapper>>* map)
 {
     // Key cannot be zero in hashmap.
     for (int i = 1; i < 11; i++)
         map->add(i, IntWrapper::create(i));
 }
 
 // crbug.com/402426
 // If it doesn't assert a concurrent modification to the map, then it's passing.
 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.
     OwnPtr<Closure> closure3 = bind(&OffHeapInt::voidFunction, RawPtr<OffHeapInt>(OffHeapInt::create(1).get()));
 
     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);
 }
 
 typedef HeapHashSet<WeakMember<IntWrapper>> WeakSet;
 
 // 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>
@@ skipping 44 matching lines @@
         set.add(IntWrapper::create(103)); // Weak set can't hold this long.
         set.add(livingInt); // This prevents the set from being emptied.
         EXPECT_EQ(2u, set.size());
     }
 
     // The set we add here is empty, so the entry will be removed from the map
     // at the next GC.
     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);
     {
         WeakSet& set = map->begin()->value;
         EXPECT_EQ(1u, set.size());
     }
 
     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());
 }
 
 TEST(HeapTest, EphemeronsInEphemerons)
 {
     typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> InnerMap;
     typedef HeapHashMap<WeakMember<IntWrapper>, InnerMap> OuterMap;
 
     for (int keepOuterAlive = 0; keepOuterAlive <= 1; keepOuterAlive++) {
         for (int keepInnerAlive = 0; keepInnerAlive <=1; keepInnerAlive++) {
             Persistent<OuterMap> outer = new OuterMap();
             Persistent<IntWrapper> one = IntWrapper::create(1);
             Persistent<IntWrapper> two = IntWrapper::create(2);
             outer->add(one, InnerMap());
             outer->begin()->value.add(two, IntWrapper::create(3));
             EXPECT_EQ(1u, outer->get(one).size());
             if (!keepOuterAlive)
                 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) {
                     EXPECT_EQ(1u, inner.size());
                     IntWrapper* three = inner.get(two);
                     EXPECT_EQ(3, three->value());
                 } else {
                     EXPECT_EQ(0u, inner.size());
                 }
             } else {
                 EXPECT_EQ(0u, outer->size());
             }
             outer->clear();
             Persistent<IntWrapper> deep = IntWrapper::create(42);
             Persistent<IntWrapper> home = IntWrapper::create(103);
             Persistent<IntWrapper> composite = IntWrapper::create(91);
             Persistent<HeapVector<Member<IntWrapper>>> keepAlive = new HeapVector<Member<IntWrapper>>();
             for (int i = 0; i < 10000; i++) {
                 IntWrapper* value = IntWrapper::create(i);
                 keepAlive->append(value);
                 OuterMap::AddResult newEntry = outer->add(value, InnerMap());
                 newEntry.storedValue->value.add(deep, home);
                 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);
                 EXPECT_EQ(1u, outer->get(value).size()); // Other one was deleted by weak handling.
                 if (i & 1)
                     keepAlive->at(i) = nullptr;
             }
-            Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+            preciselyCollectGarbage();
             EXPECT_EQ(5000u, outer->size());
         }
     }
 }
 
 class EphemeronWrapper : public GarbageCollected<EphemeronWrapper> {
 public:
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_map);
@@ skipping 15 matching lines @@
     for (int i = 0; i < 100; i++) {
         EphemeronWrapper* oldHead = chain;
         chain = new EphemeronWrapper();
         if (i == 50)
             chain->map().add(key2, oldHead);
         else
             chain->map().add(key, oldHead);
         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++) {
         EXPECT_EQ(1u, wrapper->map().size());
         if (i == 49)
             wrapper = wrapper->map().get(key2);
         else
             wrapper = wrapper->map().get(key);
     }
     EXPECT_EQ(nullptr, wrapper);
 
     key2.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     wrapper = chain;
     for (int i = 0; i < 50; i++) {
         EXPECT_EQ(i == 49 ? 0u : 1u, wrapper->map().size());
         wrapper = wrapper->map().get(key);
     }
     EXPECT_EQ(nullptr, wrapper);
 
     key.clear();
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
     EXPECT_EQ(0u, chain->map().size());
 }
 
 TEST(HeapTest, Ephemeron)
 {
     typedef HeapHashMap<WeakMember<IntWrapper>, PairWithWeakHandling>  WeakPairMap;
     typedef HeapHashMap<PairWithWeakHandling, WeakMember<IntWrapper>>  PairWeakMap;
     typedef HeapHashSet<WeakMember<IntWrapper>> Set;
 
     Persistent<WeakPairMap> weakPairMap = new WeakPairMap();
@@ skipping 28 matching lines @@
     pairWeakMap2->add(PairWithWeakHandling(pw1, pw2), pw2);
     pairWeakMap2->add(PairWithWeakHandling(pw2, pw1), pw2);
     pairWeakMap2->add(PairWithWeakHandling(pw2, pw2), pw2);
 
 
     set->add(wp1);
     set->add(wp2);
     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());
     EXPECT_EQ(1u, weakPairMap3->size());
     EXPECT_EQ(2u, weakPairMap4->size());
 
     EXPECT_EQ(3u, pairWeakMap->size());
     EXPECT_EQ(4u, pairWeakMap2->size());
 
     EXPECT_EQ(4u, set->size());
 
     wp2.clear(); // Kills all entries in the weakPairMaps except the first.
     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());
         EXPECT_EQ(0u, weakPairMap3->size());
         EXPECT_EQ(0u, weakPairMap4->size());
 
         EXPECT_EQ(1u, pairWeakMap->size());
         EXPECT_EQ(0u, pairWeakMap2->size());
 
         EXPECT_EQ(2u, set->size()); // wp1 and pw1.
     }
 
     wp1.clear();
     pw1.clear();
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    preciselyCollectGarbage();
 
     EXPECT_EQ(0u, weakPairMap->size());
     EXPECT_EQ(0u, pairWeakMap->size());
     EXPECT_EQ(0u, set->size());
 }
 
 class Link1 : public GarbageCollected<Link1> {
 public:
     Link1(IntWrapper* link) : m_link(link) { }
 
@@ skipping 10 matching lines @@
 
 TEST(HeapTest, IndirectStrongToWeak)
 {
     typedef HeapHashMap<WeakMember<IntWrapper>, Member<Link1>> Map;
     Persistent<Map> map = new Map();
     Persistent<IntWrapper> deadObject = IntWrapper::create(100); // Named for "Drowning by Numbers" (1988).
     Persistent<IntWrapper> lifeObject = IntWrapper::create(42);
     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());
 }
 
 static Mutex& mainThreadMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mainMutex, new Mutex);
     return mainMutex;
 }
 
 static ThreadCondition& mainThreadCondition()
@@ skipping 49 matching lines @@
         // Wait for the worker thread to have done its initialization,
         // IE. the worker allocates an object and then throw aways any
         // pointers to it.
         parkMainThread();
 
         // Now do a GC. This will not find the worker threads object since it
         // is not referred from any of the threads. Even a conservative
         // 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.
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
         // Put the worker thread's object address on the stack and do a
         // conservative GC. This should find the worker object, but since
         // it was dead in the previous GC it should not be traced in this
         // GC.
         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.
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
         // Wake up the worker thread so it can continue with its sweeping.
         // This should finalized the worker object which we test below.
         // The worker thread will go back to sleep once sweeping to ensure
         // we don't have thread local GCs until after validating the destructor
         // was called.
@@ skipping 69 matching lines @@
         // Wait for the worker thread initialization. The worker
         // allocates a weak collection where both collection and
         // contents are kept alive via persistent pointers.
         parkMainThread();
 
         // Perform two garbage collections where the worker thread does
         // not wake up in between. This will cause us to remove marks
         // 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
         // collection should be strongified.
         wakeWorkerThread();
 
         // Wait for the worker thread to sweep its heaps before checking.
         {
             SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             parkMainThread();
@@ skipping 44 matching lines @@
     {
         MutexLocker locker(workerThreadMutex());
 
         ThreadState::attach();
 
         {
             Persistent<WeakCollectionType> collection = allocateCollection();
             {
                 // 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());
                 EXPECT_EQ(32, it->value->value());
             }
 
             // 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());
         }
 
         wakeMainThread();
         ThreadState::detach();
     }
 
     static volatile uintptr_t s_workerObjectPointer;
 };
 
 TEST(HeapTest, ThreadedStrongification)
 {
     ThreadedStrongificationTester::test();
 }
 
 static bool allocateAndReturnBool()
 {
-    Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    conservativelyCollectGarbage();
     return true;
 }
 
 static bool checkGCForbidden()
 {
     ASSERT(ThreadState::current()->isGCForbidden());
     return true;
 }
 
 class MixinClass : public GarbageCollectedMixin {
@@ skipping 89 matching lines @@
         // Park the main thread until the worker thread has initialized.
         parkMainThread();
 
         {
             SafePointAwareMutexLocker recursiveLocker(recursiveMutex());
 
             // Let the worker try to acquire the above mutex. It won't get it
             // 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.
             EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
         }
         // At this point the main thread releases the global lock and the worker
         // can acquire it and do its sweep of its heaps. Just wait for the worker
         // to complete its sweep and check the result.
         parkMainThread();
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
@@ skipping 164 matching lines @@
         m_value = x.m_value;
         return *this;
     }
 
     enum DeletedMarker {
         DeletedValue
     };
 
     AllocatesOnAssignment(const AllocatesOnAssignment& other)
     {
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        conservativelyCollectGarbage();
         m_value = new IntWrapper(other.m_value->value());
     }
 
     AllocatesOnAssignment(DeletedMarker)
         : m_value(reinterpret_cast<IntWrapper*>(-1)) { }
 
     inline bool isDeleted() const { return m_value == reinterpret_cast<IntWrapper*>(-1); }
 
     DEFINE_INLINE_TRACE()
     {
@@ skipping 119 matching lines @@
     DEFINE_INLINE_TRACE() { }
 
     static Persistent<IntNode>* s_node;
 };
 
 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;
 }
 
 class TraceTypeEagerly1 : public GarbageCollected<TraceTypeEagerly1> { };
 class TraceTypeEagerly2 : public TraceTypeEagerly1 { };
 
 class TraceTypeNonEagerly1 { };
 WILL_NOT_BE_EAGERLY_TRACED_CLASS(TraceTypeNonEagerly1);
@@ skipping 47 matching lines @@
 int DeepEagerly::sTraceLazy = 0;
 
 TEST(HeapTest, TraceDeepEagerly)
 {
 #if !ENABLE(ASSERT)
     DeepEagerly* obj = nullptr;
     for (int i = 0; i < 10000000; i++)
         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
     // stack is switched once some nesting limit is exceeded.
     EXPECT_GT(DeepEagerly::sTraceLazy, 2);
 #endif
 }
 
 TEST(HeapTest, DequeExpand)
 {
@@ skipping 294 matching lines @@
     }
 
     int traceCount() const { return m_traceCounter->traceCount(); }
 
 private:
     TestMixinAllocatingObject(ClassWithMember* member)
         : ObjectWithLargeAmountsOfAllocationInConstructor(600, member)
         , 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);
     }
 
     Member<TraceCounter> m_traceCounter;
 };
 
 TEST(HeapTest, MixinConstructionNoGC)
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 class WeakPersistentHolder final {
 public:
     explicit WeakPersistentHolder(IntWrapper* object) : m_object(object) { }
     IntWrapper* object() const { return m_object; }
 private:
     WeakPersistent<IntWrapper> m_object;
 };
 
 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());
 }
 
 } // namespace blink