Oilpan: Refactor the way we calculate heap statistics

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 204 matching lines @@
             ThreadState::resumeThreads();
         }
     }
 
 private:
     ThreadState* m_state;
     ThreadState::SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
-static void getHeapStats(HeapStats* stats)
+static size_t objectPayloadSize()
 {
     TestGCScope scope(ThreadState::NoHeapPointersOnStack);
     EXPECT_TRUE(scope.allThreadsParked());
-    Heap::getStatsForTesting(stats);
+    return Heap::objectPayloadSizeForTesting();
 }
 
 #define DEFINE_VISITOR_METHODS(Type)                                       \
     virtual void mark(const Type* object, TraceCallback callback) override \
     {                                                                      \
         if (object)                                                        \
             m_count++;                                                     \
     }                                                                      \
     virtual bool isMarked(const Type*) override { return false; }
 
@@ skipping 122 matching lines @@
 
     int8_t at(size_t i) { return m_array[i]; }
     void trace(Visitor*) { }
 private:
     static const int s_arraySize = 1000;
     int8_t m_array[s_arraySize];
 };
 
 // Do several GCs to make sure that later GCs don't free up old memory from
 // previously run tests in this process.
-static void clearOutOldGarbage(HeapStats* heapStats)
+static void clearOutOldGarbage()
 {
     while (true) {
-        getHeapStats(heapStats);
-        size_t used = heapStats->totalObjectSpace();
+        size_t used = objectPayloadSize();
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
-        getHeapStats(heapStats);
-        if (heapStats->totalObjectSpace() >= used)
+        if (objectPayloadSize() >= used)
             break;
     }
 }
 
 class OffHeapInt : public RefCounted<OffHeapInt> {
 public:
     static RefPtr<OffHeapInt> create(int x)
     {
         return adoptRef(new OffHeapInt(x));
     }
@@ skipping 1118 matching lines @@
     ThreadedHeapTester::test();
 }
 
 TEST(HeapTest, ThreadedWeakness)
 {
     ThreadedWeaknessTester::test();
 }
 
 TEST(HeapTest, BasicFunctionality)
 {
-    HeapStats heapStats;
-    clearOutOldGarbage(&heapStats);
+    clearOutOldGarbage();
+    size_t initialObjectPayloadSize = objectPayloadSize();
     {
         size_t slack = 0;
 
         // When the test starts there may already have been leaked some memory
         // on the heap, so we establish a base line.
-        size_t baseLevel = heapStats.totalObjectSpace();
+        size_t baseLevel = initialObjectPayloadSize;
         bool testPagesAllocated = !baseLevel;
         if (testPagesAllocated)
-            EXPECT_EQ(heapStats.totalAllocatedSpace(), 0ul);
+            EXPECT_EQ(Heap::allocatedSpace(), 0ul);
 
         // This allocates objects on the general heap which should add a page of memory.
         DynamicallySizedObject* alloc32 = DynamicallySizedObject::create(32);
         slack += 4;
         memset(alloc32, 40, 32);
         DynamicallySizedObject* alloc64 = DynamicallySizedObject::create(64);
         slack += 4;
         memset(alloc64, 27, 64);
 
         size_t total = 96;
 
-        getHeapStats(&heapStats);
-        CheckWithSlack(baseLevel + total, heapStats.totalObjectSpace(), slack);
+        CheckWithSlack(baseLevel + total, objectPayloadSize(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(heapStats.totalAllocatedSpace(), 2 * blinkPageSize);
+            EXPECT_EQ(Heap::allocatedSpace(), 2 * blinkPageSize);
 
         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);
 
         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(&heapStats);
+    clearOutOldGarbage();
     size_t total = 0;
     size_t slack = 0;
-    size_t baseLevel = heapStats.totalObjectSpace();
+    size_t baseLevel = objectPayloadSize();
     bool testPagesAllocated = !baseLevel;
     if (testPagesAllocated)
-        EXPECT_EQ(heapStats.totalAllocatedSpace(), 0ul);
+        EXPECT_EQ(Heap::allocatedSpace(), 0ul);
 
     size_t big = 1008;
     Persistent<DynamicallySizedObject> bigArea = DynamicallySizedObject::create(big);
     total += big;
     slack += 4;
 
     size_t persistentCount = 0;
     const size_t numPersistents = 100000;
     Persistent<DynamicallySizedObject>* persistents[numPersistents];
 
     for (int i = 0; i < 1000; i++) {
         size_t size = 128 + i * 8;
         total += size;
         persistents[persistentCount++] = new Persistent<DynamicallySizedObject>(DynamicallySizedObject::create(size));
         slack += 4;
-        getHeapStats(&heapStats);
-        CheckWithSlack(baseLevel + total, heapStats.totalObjectSpace(), slack);
+        CheckWithSlack(baseLevel + total, objectPayloadSize(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, heapStats.totalAllocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
     }
 
     {
         DynamicallySizedObject* alloc32b(DynamicallySizedObject::create(32));
         slack += 4;
         memset(alloc32b, 40, 32);
         DynamicallySizedObject* alloc64b(DynamicallySizedObject::create(64));
         slack += 4;
         memset(alloc64b, 27, 64);
         EXPECT_TRUE(alloc32b != alloc64b);
 
         total += 96;
-        getHeapStats(&heapStats);
-        CheckWithSlack(baseLevel + total, heapStats.totalObjectSpace(), slack);
+        CheckWithSlack(baseLevel + total, objectPayloadSize(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, heapStats.totalAllocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
     }
 
-    clearOutOldGarbage(&heapStats);
+    clearOutOldGarbage();
     total -= 96;
     slack -= 8;
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, heapStats.totalAllocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
 
     // Clear the persistent, so that the big area will be garbage collected.
     bigArea.release();
-    clearOutOldGarbage(&heapStats);
+    clearOutOldGarbage();
 
     total -= big;
     slack -= 4;
-    getHeapStats(&heapStats);
-    CheckWithSlack(baseLevel + total, heapStats.totalObjectSpace(), slack);
+    CheckWithSlack(baseLevel + total, objectPayloadSize(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, heapStats.totalAllocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
 
-    getHeapStats(&heapStats);
-    CheckWithSlack(baseLevel + total, heapStats.totalObjectSpace(), slack);
+    CheckWithSlack(baseLevel + total, objectPayloadSize(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, heapStats.totalAllocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
 
     for (size_t i = 0; i < persistentCount; i++) {
         delete persistents[i];
         persistents[i] = 0;
     }
 
     uint8_t* address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(0, 100));
     for (int i = 0; i < 100; i++)
         address[i] = i;
     address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 100000));
     for (int i = 0; i < 100; i++)
         EXPECT_EQ(address[i], i);
     address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 50));
     for (int i = 0; i < 50; i++)
         EXPECT_EQ(address[i], i);
     // This should be equivalent to free(address).
     EXPECT_EQ(reinterpret_cast<uintptr_t>(Heap::reallocate<DynamicallySizedObject>(address, 0)), 0ul);
     // This should be equivalent to malloc(0).
     EXPECT_EQ(reinterpret_cast<uintptr_t>(Heap::reallocate<DynamicallySizedObject>(0, 0)), 0ul);
 }
 
 TEST(HeapTest, SimpleAllocation)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
-    EXPECT_EQ(0ul, initialHeapStats.totalObjectSpace());
+    clearOutOldGarbage();
+    EXPECT_EQ(0ul, objectPayloadSize());
 
     // Allocate an object in the heap.
     HeapAllocatedArray* array = new HeapAllocatedArray();
-    HeapStats statsAfterAllocation;
-    getHeapStats(&statsAfterAllocation);
-    EXPECT_TRUE(statsAfterAllocation.totalObjectSpace() >= sizeof(HeapAllocatedArray));
+    EXPECT_TRUE(objectPayloadSize() >= sizeof(HeapAllocatedArray));
 
     // Sanity check of the contents in the heap.
     EXPECT_EQ(0, array->at(0));
     EXPECT_EQ(42, array->at(42));
     EXPECT_EQ(0, array->at(128));
     EXPECT_EQ(999 % 128, array->at(999));
 }
 
 TEST(HeapTest, SimplePersistent)
 {
@@ skipping 150 matching lines @@
         // for the conservative stack scan to find.
         EXPECT_EQ(width, bars->getWidth());
     }
     EXPECT_EQ(Bars::width + 1, Bar::s_live);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
 }
 
 TEST(HeapTest, HashMapOfMembers)
 {
-    HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
+    size_t initialObjectPayloadSize = objectPayloadSize();
     {
         typedef HeapHashMap<
             Member<IntWrapper>,
             Member<IntWrapper>,
             DefaultHash<Member<IntWrapper> >::Hash,
             HashTraits<Member<IntWrapper> >,
             HashTraits<Member<IntWrapper> > > HeapObjectIdentityMap;
 
         Persistent<HeapObjectIdentityMap> map = new HeapObjectIdentityMap();
 
         map->clear();
-        HeapStats afterSetWasCreated;
-        getHeapStats(&afterSetWasCreated);
-        EXPECT_TRUE(afterSetWasCreated.totalObjectSpace() > initialHeapSize.totalObjectSpace());
+        size_t afterSetWasCreated = objectPayloadSize();
+        EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
-        HeapStats afterGC;
-        getHeapStats(&afterGC);
-        EXPECT_EQ(afterGC.totalObjectSpace(), afterSetWasCreated.totalObjectSpace());
+        size_t afterGC = objectPayloadSize();
+        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);
 
-        HeapStats afterOneAdd;
-        getHeapStats(&afterOneAdd);
-        EXPECT_TRUE(afterOneAdd.totalObjectSpace() > afterGC.totalObjectSpace());
+        size_t afterOneAdd = objectPayloadSize();
+        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);
-        HeapStats afterAddAndGC;
-        getHeapStats(&afterAddAndGC);
-        EXPECT_TRUE(afterAddAndGC.totalObjectSpace() >= afterOneAdd.totalObjectSpace());
+        size_t afterAddAndGC = objectPayloadSize();
+        EXPECT_TRUE(afterAddAndGC >= afterOneAdd);
 
         EXPECT_EQ(map->size(), 2u); // Two different wrappings of '1' are distinct.
 
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         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);
 
-        HeapStats afterGC2;
-        getHeapStats(&afterGC2);
-        EXPECT_EQ(afterGC2.totalObjectSpace(), afterAddAndGC.totalObjectSpace());
+        size_t afterGC2 = objectPayloadSize();
+        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;
         }
-        HeapStats afterAdding1000;
-        getHeapStats(&afterAdding1000);
-        EXPECT_TRUE(afterAdding1000.totalObjectSpace() > afterGC2.totalObjectSpace());
+        size_t afterAdding1000 = objectPayloadSize();
+        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);
-        HeapStats afterGC3;
-        getHeapStats(&afterGC3);
-        EXPECT_TRUE(afterGC3.totalObjectSpace() <= afterAdding1000.totalObjectSpace());
+        size_t afterGC3 = objectPayloadSize();
+        EXPECT_TRUE(afterGC3 <= afterAdding1000);
     }
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     // The objects 'one', anotherOne, and the 999 other pairs.
     EXPECT_EQ(IntWrapper::s_destructorCalls, 2000);
-    HeapStats afterGC4;
-    getHeapStats(&afterGC4);
-    EXPECT_EQ(afterGC4.totalObjectSpace(), initialHeapSize.totalObjectSpace());
+    size_t afterGC4 = objectPayloadSize();
+    EXPECT_EQ(afterGC4, initialObjectPayloadSize);
 }
 
 TEST(HeapTest, NestedAllocation)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
+    size_t initialObjectPayloadSize = objectPayloadSize();
     {
         Persistent<ConstructorAllocation> constructorAllocation = ConstructorAllocation::create();
     }
-    HeapStats afterFree;
-    clearOutOldGarbage(&afterFree);
-    EXPECT_TRUE(initialHeapSize == afterFree);
+    clearOutOldGarbage();
+    size_t afterFree = objectPayloadSize();
+    EXPECT_TRUE(initialObjectPayloadSize == afterFree);
 }
 
 TEST(HeapTest, LargeObjects)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
+    size_t initialObjectPayloadSize = objectPayloadSize();
+    size_t initialAllocatedSpace = Heap::allocatedSpace();
     IntWrapper::s_destructorCalls = 0;
     LargeObject::s_destructorCalls = 0;
     {
         int slack = 8; // LargeObject points to an IntWrapper that is also allocated.
         Persistent<LargeObject> object = LargeObject::create();
         EXPECT_TRUE(ThreadState::current()->contains(object));
         EXPECT_TRUE(ThreadState::current()->contains(reinterpret_cast<char*>(object.get()) + sizeof(LargeObject) - 1));
 #if ENABLE(GC_PROFILE_MARKING)
         const GCInfo* info = ThreadState::current()->findGCInfo(reinterpret_cast<Address>(object.get()));
         EXPECT_NE(reinterpret_cast<const GCInfo*>(0), info);
         EXPECT_EQ(info, ThreadState::current()->findGCInfo(reinterpret_cast<Address>(object.get()) + sizeof(LargeObject) - 1));
         EXPECT_NE(info, ThreadState::current()->findGCInfo(reinterpret_cast<Address>(object.get()) + sizeof(LargeObject)));
         EXPECT_NE(info, ThreadState::current()->findGCInfo(reinterpret_cast<Address>(object.get()) - 1));
 #endif
-        HeapStats afterAllocation;
-        clearOutOldGarbage(&afterAllocation);
+        clearOutOldGarbage();
+        size_t afterAllocation = Heap::allocatedSpace();
         {
             object->set(0, 'a');
             EXPECT_EQ('a', object->get(0));
             object->set(object->length() - 1, 'b');
             EXPECT_EQ('b', object->get(object->length() - 1));
-            size_t expectedObjectSpace = sizeof(LargeObject) + sizeof(IntWrapper);
-            size_t actualObjectSpace =
-                afterAllocation.totalObjectSpace() - initialHeapSize.totalObjectSpace();
-            CheckWithSlack(expectedObjectSpace, actualObjectSpace, slack);
+            size_t expectedObjectPayloadSize = sizeof(LargeObject) + sizeof(IntWrapper);
+            size_t actualObjectPayloadSize = objectPayloadSize() - initialObjectPayloadSize;
+            CheckWithSlack(expectedObjectPayloadSize, actualObjectPayloadSize, slack);
             // There is probably space for the IntWrapper in a heap page without
             // allocating extra pages. However, the IntWrapper allocation might cause
             // the addition of a heap page.
             size_t largeObjectAllocationSize =
                 sizeof(LargeObject) + sizeof(LargeHeapObject<FinalizedHeapObjectHeader>) + sizeof(FinalizedHeapObjectHeader);
-            size_t allocatedSpaceLowerBound =
-                initialHeapSize.totalAllocatedSpace() + largeObjectAllocationSize;
+            size_t allocatedSpaceLowerBound = initialAllocatedSpace + largeObjectAllocationSize;
             size_t allocatedSpaceUpperBound = allocatedSpaceLowerBound + slack + blinkPageSize;
-            EXPECT_LE(allocatedSpaceLowerBound, afterAllocation.totalAllocatedSpace());
-            EXPECT_LE(afterAllocation.totalAllocatedSpace(), allocatedSpaceUpperBound);
+            EXPECT_LE(allocatedSpaceLowerBound, afterAllocation);
+            EXPECT_LE(afterAllocation, allocatedSpaceUpperBound);
             EXPECT_EQ(0, IntWrapper::s_destructorCalls);
             EXPECT_EQ(0, LargeObject::s_destructorCalls);
             for (int i = 0; i < 10; i++)
                 object = LargeObject::create();
         }
-        HeapStats oneLargeObject;
-        clearOutOldGarbage(&oneLargeObject);
-        EXPECT_TRUE(oneLargeObject == afterAllocation);
+        clearOutOldGarbage();
+        EXPECT_TRUE(Heap::allocatedSpace() == afterAllocation);
         EXPECT_EQ(10, IntWrapper::s_destructorCalls);
         EXPECT_EQ(10, LargeObject::s_destructorCalls);
     }
-    HeapStats backToInitial;
-    clearOutOldGarbage(&backToInitial);
-    EXPECT_TRUE(initialHeapSize == backToInitial);
+    clearOutOldGarbage();
+    EXPECT_TRUE(initialObjectPayloadSize == objectPayloadSize());
+    EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeObject::s_destructorCalls);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 }
 
 typedef std::pair<Member<IntWrapper>, int> PairWrappedUnwrapped;
 typedef std::pair<int, Member<IntWrapper> > PairUnwrappedWrapped;
 typedef std::pair<WeakMember<IntWrapper>, Member<IntWrapper> > PairWeakStrong;
 typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper> > PairStrongWeak;
 typedef std::pair<WeakMember<IntWrapper>, int> PairWeakUnwrapped;
@@ skipping 179 matching lines @@
     typedef typename HeapDeque<T, inlineCapacity>::iterator iterator;
     for (iterator it = deque.begin(); it != deque.end(); ++it) {
         if (*it == u)
             return true;
     }
     return false;
 }
 
 TEST(HeapTest, HeapCollectionTypes)
 {
-    HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
     typedef HeapHashMap<Member<IntWrapper>, Member<IntWrapper> > MemberMember;
     typedef HeapHashMap<Member<IntWrapper>, int> MemberPrimitive;
     typedef HeapHashMap<int, Member<IntWrapper> > PrimitiveMember;
 
     typedef HeapHashSet<Member<IntWrapper> > MemberSet;
     typedef HeapHashCountedSet<Member<IntWrapper> > MemberCountedSet;
 
     typedef HeapVector<Member<IntWrapper>, 2> MemberVector;
@@ skipping 19 matching lines @@
     Persistent<VectorUW> vectorUW = new VectorUW();
     Persistent<VectorUW> vectorUW2 = new VectorUW();
     Persistent<MemberDeque> deque = new MemberDeque();
     Persistent<MemberDeque> deque2 = new MemberDeque();
     Persistent<DequeWU> dequeWU = new DequeWU();
     Persistent<DequeWU> dequeWU2 = new DequeWU();
     Persistent<DequeUW> dequeUW = new DequeUW();
     Persistent<DequeUW> dequeUW2 = new DequeUW();
     Persistent<Container> container = Container::create();
 
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     {
         Persistent<IntWrapper> one(IntWrapper::create(1));
         Persistent<IntWrapper> two(IntWrapper::create(2));
         Persistent<IntWrapper> oneB(IntWrapper::create(1));
         Persistent<IntWrapper> twoB(IntWrapper::create(2));
         Persistent<IntWrapper> oneC(IntWrapper::create(1));
         Persistent<IntWrapper> oneD(IntWrapper::create(1));
         Persistent<IntWrapper> oneE(IntWrapper::create(1));
         Persistent<IntWrapper> oneF(IntWrapper::create(1));
         {
@@ skipping 262 matching lines @@
         found++;
         int value = (*it)->value();
         EXPECT_TRUE(value >= 0 && value < 1100);
         ++it;
     }
     EXPECT_EQ(expected, found);
 }
 
 TEST(HeapTest, HeapWeakCollectionSimple)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
     PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
 
     typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakStrong;
     typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper> > StrongWeak;
     typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper> > WeakWeak;
     typedef HeapHashSet<WeakMember<IntWrapper> > WeakSet;
     typedef HeapHashCountedSet<WeakMember<IntWrapper> > WeakCountedSet;
 
@@ skipping 40 matching lines @@
     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)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
     PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
 
     Persistent<Set> set1 = new Set();
     Persistent<Set> set2 = new Set();
 
     const Set& constSet = *set1.get();
 
     keepNumbersAlive.append(IntWrapper::create(2));
@@ skipping 138 matching lines @@
 };
 
 int ThingWithDestructor::s_liveThingsWithDestructor;
 
 struct ThingWithDestructorTraits : public HashTraits<ThingWithDestructor> {
     static const bool needsDestruction = true;
 };
 
 static void heapMapDestructorHelper(bool clearMaps)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
     ThingWithDestructor::s_liveThingsWithDestructor = 0;
 
     typedef HeapHashMap<WeakMember<IntWrapper>, Member<RefCountedAndGarbageCollected> > RefMap;
 
     typedef HeapHashMap<
         WeakMember<IntWrapper>,
         ThingWithDestructor,
         DefaultHash<WeakMember<IntWrapper> >::Hash,
         HashTraits<WeakMember<IntWrapper> >,
         ThingWithDestructorTraits> Map;
@@ skipping 203 matching lines @@
         typedef HeapLinkedHashSet<PairWeakStrong> WeakStrongSet;
         typedef HeapLinkedHashSet<PairWeakUnwrapped> WeakUnwrappedSet;
         typedef HeapLinkedHashSet<PairStrongWeak> StrongWeakSet;
         typedef HeapLinkedHashSet<PairUnwrappedWeak> UnwrappedWeakSet;
         weakPairsHelper<WeakStrongSet, StrongWeakSet, WeakUnwrappedSet, UnwrappedWeakSet>();
     }
 }
 
 TEST(HeapTest, HeapWeakCollectionTypes)
 {
-    HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
     typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakStrong;
     typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper> > StrongWeak;
     typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper> > WeakWeak;
     typedef HeapHashSet<WeakMember<IntWrapper> > WeakSet;
     typedef HeapLinkedHashSet<WeakMember<IntWrapper> > WeakOrderedSet;
 
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
 
     const int weakStrongIndex = 0;
     const int strongWeakIndex = 1;
     const int weakWeakIndex = 2;
     const int numberOfMapIndices = 3;
     const int weakSetIndex = 3;
     const int weakOrderedSetIndex = 4;
     const int numberOfCollections = 5;
 
     for (int testRun = 0; testRun < 4; testRun++) {
@@ skipping 365 matching lines @@
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
     EXPECT_TRUE(barPersistent != fooPersistent);
     barPersistent = fooPersistent;
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
 
     Vector<Address> objectAddresses;
     Vector<Address> endAddresses;
     Address largeObjectAddress;
     Address largeObjectEndAddress;
     CountingVisitor visitor;
     for (int i = 0; i < 10; i++) {
         SimpleObject* object = SimpleObject::create();
         Address objectAddress = reinterpret_cast<Address>(object);
         objectAddresses.append(objectAddress);
@@ skipping 22 matching lines @@
         EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
         visitor.reset();
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
         EXPECT_EQ(2ul, visitor.count());
         visitor.reset();
     }
     // This forces a GC without stack scanning which results in the objects
     // being collected. This will also rebuild the above mentioned freelists,
     // however we don't rely on that below since we don't have any allocations.
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
     {
         TestGCScope scope(ThreadState::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked());
         Heap::prepareForGC();
         Heap::flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             // We would like to assert that checkAndMarkPointer returned false
             // here because the pointers no longer point into a valid object
             // (it's been freed by the GCs. But checkAndMarkPointer will return
             // true for any pointer that points into a heap page, regardless of
             // whether it points at a valid object (this ensures the
             // correctness of the page-based on-heap address caches), so we
             // can't make that assert.
             Heap::checkAndMarkPointer(&visitor, objectAddresses[i]);
             Heap::checkAndMarkPointer(&visitor, endAddresses[i]);
         }
         EXPECT_EQ(0ul, visitor.count());
         Heap::checkAndMarkPointer(&visitor, largeObjectAddress);
         Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress);
         EXPECT_EQ(0ul, visitor.count());
     }
     // This round of GC is important to make sure that the object start
     // bitmap are cleared out and that the free lists are rebuild.
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
 }
 
 TEST(HeapTest, VisitOffHeapCollections)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     Persistent<OffHeapContainer> container = OffHeapContainer::create();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     container = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(OffHeapContainer::deadWrappers, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, PersistentHeapCollectionTypes)
 {
-    HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
     typedef HeapVector<Member<IntWrapper> > Vec;
     typedef PersistentHeapVector<Member<IntWrapper> > PVec;
     typedef PersistentHeapHashSet<Member<IntWrapper> > PSet;
     typedef PersistentHeapListHashSet<Member<IntWrapper> > PListSet;
     typedef PersistentHeapLinkedHashSet<Member<IntWrapper> > PLinkedSet;
     typedef PersistentHeapHashMap<Member<IntWrapper>, Member<IntWrapper> > PMap;
     typedef PersistentHeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakPMap;
     typedef PersistentHeapDeque<Member<IntWrapper> > PDeque;
 
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     {
         PVec pVec;
         PDeque pDeque;
         PSet pSet;
         PListSet pListSet;
         PLinkedSet pLinkedSet;
         PMap pMap;
         WeakPMap wpMap;
 
         IntWrapper* one(IntWrapper::create(1));
@@ skipping 61 matching lines @@
         EXPECT_EQ(0u, wpMap.size());
     }
 
     // Collect previous roots.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting)
 {
-    HeapStats initialStats;
-    clearOutOldGarbage(&initialStats);
+    clearOutOldGarbage();
     int* key = &IntWrapper::s_destructorCalls;
     IntWrapper::s_destructorCalls = 0;
     typedef HeapVector<Member<IntWrapper> > IntVector;
     typedef HeapDeque<Member<IntWrapper> > IntDeque;
     HeapHashMap<void*, IntVector>* map = new HeapHashMap<void*, IntVector>();
     HeapHashMap<void*, IntDeque>* map2 = new HeapHashMap<void*, IntDeque>();
 
     map->add(key, IntVector());
     map2->add(key, IntDeque());
 
@@ skipping 23 matching lines @@
     EXPECT_EQ(1u, map2->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
     keepAlive = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, GarbageCollectedMixin)
 {
-    HeapStats initialHeapStats;
-    clearOutOldGarbage(&initialHeapStats);
+    clearOutOldGarbage();
 
     Persistent<UseMixin> usemixin = UseMixin::create();
     EXPECT_EQ(0, UseMixin::s_traceCount);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1, UseMixin::s_traceCount);
 
     Persistent<Mixin> mixin = usemixin;
     usemixin = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(2, UseMixin::s_traceCount);
 
     PersistentHeapHashSet<WeakMember<Mixin> > weakMap;
     weakMap.add(UseMixin::create());
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, weakMap.size());
 }
 
 TEST(HeapTest, CollectionNesting2)
 {
-    HeapStats initialStats;
-    clearOutOldGarbage(&initialStats);
+    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);
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting3)
 {
-    HeapStats initialStats;
-    clearOutOldGarbage(&initialStats);
+    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);
     EXPECT_EQ(1u, it->size());
     EXPECT_EQ(1u, it2->size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInVector)
 {
-    HeapStats initialStats;
-    clearOutOldGarbage(&initialStats);
+    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);
@@ skipping 18 matching lines @@
         vectorNoTrace.append(n2);
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(2, SimpleFinalizedObject::s_destructorCalls);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(8, SimpleFinalizedObject::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInDeque)
 {
-    HeapStats initialStats;
-    clearOutOldGarbage(&initialStats);
+    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);
@@ skipping 38 matching lines @@
 
 TEST(HeapTest, RawPtrInHash)
 {
     rawPtrInHashHelper<HashSet<RawPtr<int> > >();
     rawPtrInHashHelper<ListHashSet<RawPtr<int> > >();
     rawPtrInHashHelper<LinkedHashSet<RawPtr<int> > >();
 }
 
 TEST(HeapTest, HeapTerminatedArray)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
     HeapTerminatedArray<TerminatedArrayItem>* arr = 0;
 
     const size_t prefixSize = 4;
     const size_t suffixSize = 4;
 
     {
         HeapTerminatedArrayBuilder<TerminatedArrayItem> builder(arr);
         builder.grow(prefixSize);
@@ skipping 33 matching lines @@
             EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
     }
 
     arr = 0;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(8, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, HeapLinkedStack)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    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);
     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);
     EXPECT_EQ(stackSize, static_cast<size_t>(IntWrapper::s_destructorCalls));
     EXPECT_EQ(0u, pStack->size());
 }
 
 TEST(HeapTest, AllocationDuringFinalization)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     OneKiloByteObject::s_destructorCalls = 0;
 
     Persistent<IntWrapper> wrapper;
     new FinalizationAllocator(&wrapper);
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     // Check that the wrapper allocated during finalization is not
     // swept away and zapped later in the same sweeping phase.
@@ skipping 135 matching lines @@
 };
 
 static const bool s_isMixinTrue = IsGarbageCollectedMixin<MultipleMixins>::value;
 static const bool s_isMixinFalse = IsGarbageCollectedMixin<IntWrapper>::value;
 
 TEST(HeapTest, MultipleMixins)
 {
     EXPECT_TRUE(s_isMixinTrue);
     EXPECT_FALSE(s_isMixinFalse);
 
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
     MultipleMixins* obj = new MultipleMixins();
     {
         Persistent<MixinA> a = obj;
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     }
     {
         Persistent<MixinB> b = obj;
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
@@ skipping 134 matching lines @@
 TEST(HeapTest, SetWithCustomWeaknessHandling)
 {
     setWithCustomWeaknessHandling<HeapHashSet<PairWithWeakHandling> >();
     setWithCustomWeaknessHandling<HeapLinkedHashSet<PairWithWeakHandling> >();
 }
 
 TEST(HeapTest, MapWithCustomWeaknessHandling)
 {
     typedef HeapHashMap<PairWithWeakHandling, RefPtr<OffHeapInt> > Map;
     typedef Map::iterator Iterator;
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     OffHeapInt::s_destructorCalls = 0;
 
     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));
@@ skipping 48 matching lines @@
     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;
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    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)));
@@ skipping 123 matching lines @@
 // 1) We can't just override the HashTrait for the type since this would affect
 //    all collections that use this kind of weak set. Instead we have our own
 //    traits and use a map with custom traits for the value type. These traits
 //    are the 5th template parameter, so we have to supply default values for
 //    the 3rd and 4th template parameters
 // 2) We can't just inherit from WeakHandlingHashTraits, since that trait
 //    assumes we can add methods to the type, but we can't add methods to
 //    HeapHashSet.
 TEST(HeapTest, RemoveEmptySets)
 {
-    HeapStats initialHeapSize;
-    clearOutOldGarbage(&initialHeapSize);
+    clearOutOldGarbage();
     OffHeapInt::s_destructorCalls = 0;
 
     Persistent<IntWrapper> livingInt(IntWrapper::create(42));
 
     typedef RefPtr<OffHeapInt> Key;
     typedef HeapHashMap<Key, WeakSet, WTF::DefaultHash<Key>::Hash, HashTraits<Key>, EmptyClearingHashSetTraits> Map;
     Persistent<Map> map(new Map());
     map->add(OffHeapInt::create(1), WeakSet());
     {
         WeakSet& set = map->begin()->value;
@@ skipping 1015 matching lines @@
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
 } // namespace blink