Use the partition allocator and run the test in debug too.

Source/wtf/PartitionAlloc.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 67 matching lines @@
 static void partitionCollectIfSuperPage(PartitionPageHeader* partitionPage, Vector<PartitionPageHeader*>* superPages)
 {
     PartitionPageHeader* superPage = reinterpret_cast<PartitionPageHeader*>(reinterpret_cast<uintptr_t>(partitionPage) & kSuperPageBaseMask);
     uintptr_t superPageOffset = reinterpret_cast<uintptr_t>(partitionPage) & kSuperPageOffsetMask;
     // If this partition page is at the start of a super page, note it so we can
     // free all the distinct super pages.
     if (!superPageOffset)
         superPages->append(superPage);
 }
 
-static void partitionAllocShutdownBucket(PartitionBucket* bucket, Vector<PartitionPageHeader*>* superPages)
+static bool partitionAllocShutdownBucket(PartitionBucket* bucket, Vector<PartitionPageHeader*>* superPages)
 {
     // Failure here indicates a memory leak.
-    ASSERT(!bucket->numFullPages);
+    bool noLeaks = !bucket->numFullPages;
     PartitionFreepagelistEntry* entry = bucket->freePages;
     while (entry) {
         PartitionFreepagelistEntry* next = entry->next;
         partitionCollectIfSuperPage(entry->page, superPages);
         partitionFree(entry);
         entry = next;
     }
     PartitionPageHeader* page = bucket->currPage;
     do {
-        // Failure here indicates a memory leak.
-        ASSERT(bucket == &bucket->root->buckets[kFreePageBucket] || !page->numAllocatedSlots);
+        if (page->numAllocatedSlots)
+            noLeaks = false;
         PartitionPageHeader* next = page->next;
         if (page != &bucket->root->seedPage)
             partitionCollectIfSuperPage(page, superPages);
         page = next;
     } while (page != bucket->currPage);
+
+    return noLeaks;
 }
 
-void partitionAllocShutdown(PartitionRoot* root)
+bool partitionAllocShutdown(PartitionRoot* root)
 {
+    bool noLeaks = true;
     ASSERT(root->initialized);
     root->initialized = false;
     // As we iterate through all the partition pages, we keep a list of all the
     // distinct super pages that we have seen. This is so that we can free all
     // the super pages correctly. A super page must be freed all at once -- it
     // is not permissible to free a super page by freeing all its component
     // partition pages.
     // Note that we cannot free a super page upon discovering it, because a
     // single super page will likely contain partition pages from multiple
     // different buckets.
     Vector<PartitionPageHeader*> superPages;
     size_t i;
     // First, free the non-freepage buckets. Freeing the free pages in these
     // buckets will depend on the freepage bucket.
     for (i = 0; i < kNumBuckets; ++i) {
         if (i != kFreePageBucket) {
             PartitionBucket* bucket = &root->buckets[i];
-            partitionAllocShutdownBucket(bucket, &superPages);
+            if (!partitionAllocShutdownBucket(bucket, &superPages))
+                noLeaks = false;
         }
     }
     // Finally, free the freepage bucket.
-    partitionAllocShutdownBucket(&root->buckets[kFreePageBucket], &superPages);
+    (void) partitionAllocShutdownBucket(&root->buckets[kFreePageBucket], &superPages);
     // Now that we've examined all partition pages in all buckets, it's safe
     // to free all our super pages.
     for (Vector<PartitionPageHeader*>::iterator it = superPages.begin(); it != superPages.end(); ++it)
         partitionFreeSuperPage(*it);
+
+    return noLeaks;
 }
 
 static ALWAYS_INLINE PartitionPageHeader* partitionAllocPage(PartitionRoot* root)
 {
     char* ret = 0;
     if (LIKELY(root->nextPartitionPage != 0)) {
         // In this case, we can still hand out pages from a previous
         // super page allocation.
         ret = root->nextPartitionPage;
         root->nextPartitionPage += kPartitionPageSize;
@@ skipping 198 matching lines @@
             }
             page = page->next;
         } while (page != bucket.currPage);
         printf("bucket size %ld: %ld/%ld bytes, %ld free pages\n", bucketSlotSize, numActiveBytes, numActivePages * kPartitionPageSize, numFreePages);
     }
 }
 #endif // !NDEBUG
 
 } // namespace WTF