Report DOM partitionAlloc size to V8 GC.

Source/wtf/PartitionAllocTest.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 972 matching lines @@
     }
 
     TestShutdown();
 }
 
 // Tests that pages in the free page cache do get freed as appropriate.
 TEST(PartitionAllocTest, FreeCache)
 {
     TestSetup();
 
+    EXPECT_EQ(0U, allocator.root()->totalSizeOfCommittedPages);
+
     size_t bigSize = allocator.root()->maxAllocation - kExtraAllocSize;
     size_t bucketIdx = (bigSize + kExtraAllocSize) >> WTF::kBucketShift;
     WTF::PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
 
     void* ptr = partitionAlloc(allocator.root(), bigSize);
     EXPECT_TRUE(ptr);
     WTF::PartitionPage* page = WTF::partitionPointerToPage(WTF::partitionCookieFreePointerAdjust(ptr));
     EXPECT_EQ(0, bucket->freePagesHead);
     EXPECT_EQ(1, page->numAllocatedSlots);
+    EXPECT_EQ(WTF::kPartitionPageSize, allocator.root()->totalSizeOfCommittedPages);
     partitionFree(ptr);
     EXPECT_EQ(0, page->numAllocatedSlots);
     EXPECT_NE(-1, page->freeCacheIndex);
     EXPECT_TRUE(page->freelistHead);
 
     CycleFreeCache(kTestAllocSize);
 
     // Flushing the cache should have really freed the unused page.
     EXPECT_FALSE(page->freelistHead);
     EXPECT_EQ(-1, page->freeCacheIndex);
     EXPECT_EQ(0, page->numAllocatedSlots);
+    WTF::PartitionBucket* cycleFreeCacheBucket = &allocator.root()->buckets()[kTestBucketIndex];
+    EXPECT_EQ(cycleFreeCacheBucket->numSystemPagesPerSlotSpan * WTF::kSystemPageSize, allocator.root()->totalSizeOfCommittedPages);
 
     // Check that an allocation works ok whilst in this state (a free'd page
     // as the active pages head).
     ptr = partitionAlloc(allocator.root(), bigSize);
     EXPECT_FALSE(bucket->freePagesHead);
     partitionFree(ptr);
 
     // Also check that a page that is bouncing immediately between empty and
     // used does not get freed.
     for (size_t i = 0; i < WTF::kMaxFreeableSpans * 2; ++i) {
         ptr = partitionAlloc(allocator.root(), bigSize);
         EXPECT_TRUE(page->freelistHead);
         partitionFree(ptr);
         EXPECT_TRUE(page->freelistHead);
     }
-
+    EXPECT_EQ(WTF::kPartitionPageSize, allocator.root()->totalSizeOfCommittedPages);
     TestShutdown();
 }
 
 // Tests for a bug we had with losing references to free pages.
 TEST(PartitionAllocTest, LostFreePagesBug)
 {
     TestSetup();
 
     size_t size = WTF::kPartitionPageSize - kExtraAllocSize;
 
@@ skipping 144 matching lines @@
     EXPECT_EQ(32u, WTF::countLeadingZerosSizet(0));
     EXPECT_EQ(31u, WTF::countLeadingZerosSizet(1));
     EXPECT_EQ(1u, WTF::countLeadingZerosSizet(1 << 30));
     EXPECT_EQ(0u, WTF::countLeadingZerosSizet(1 << 31));
 #endif
 }
 
 } // namespace
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)