Add partitionsOutOfMemoryUsingXXX to know Blink memory usage from OOM crash reports

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 41 matching lines @@
 // Check that some of our zanier calculations worked out as expected.
 static_assert(WTF::kGenericSmallestBucket == 8, "generic smallest bucket");
 static_assert(WTF::kGenericMaxBucketed == 983040, "generic max bucketed");
 
 namespace WTF {
 
 int PartitionRootBase::gInitializedLock = 0;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
+void (*PartitionRootBase::gOomHandlingFunction)() = nullptr;
 
 static uint16_t partitionBucketNumSystemPages(size_t size)
 {
     // This works out reasonably for the current bucket sizes of the generic
     // allocator, and the current values of partition page size and constants.
     // Specifically, we have enough room to always pack the slots perfectly into
     // some number of system pages. The only waste is the waste associated with
     // unfaulted pages (i.e. wasted address space).
     // TODO: we end up using a lot of system pages for very small sizes. For
     // example, we'll use 12 system pages for slot size 24. The slot size is
@@ skipping 59 matching lines @@
 
 static void partitionBucketInitBase(PartitionBucket* bucket, PartitionRootBase* root)
 {
     bucket->activePagesHead = &PartitionRootGeneric::gSeedPage;
     bucket->emptyPagesHead = 0;
     bucket->decommittedPagesHead = 0;
     bucket->numFullPages = 0;
     bucket->numSystemPagesPerSlotSpan = partitionBucketNumSystemPages(bucket->slotSize);
 }
 
+void partitionAllocGlobalInit(void (*oomHandlingFunction)())
+{
+    ASSERT(oomHandlingFunction);
+    PartitionRootBase::gOomHandlingFunction = oomHandlingFunction;
+}
+
 void partitionAllocInit(PartitionRoot* root, size_t numBuckets, size_t maxAllocation)
 {
     partitionAllocBaseInit(root);
 
     root->numBuckets = numBuckets;
     root->maxAllocation = maxAllocation;
     size_t i;
     for (i = 0; i < root->numBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets()[i];
         if (!i)
@@ skipping 150 matching lines @@
 
 static NEVER_INLINE void partitionOutOfMemory(const PartitionRootBase* root)
 {
 #if !CPU(64BIT)
     // Check whether this OOM is due to a lot of super pages that are allocated
     // but not committed, probably due to http://crbug.com/421387.
     if (root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages - root->totalSizeOfCommittedPages > kReasonableSizeOfUnusedPages) {
         partitionOutOfMemoryWithLotsOfUncommitedPages();
     }
 #endif
+    if (PartitionRootBase::gOomHandlingFunction)
+        (*PartitionRootBase::gOomHandlingFunction)();
     IMMEDIATE_CRASH();
 }
 
 static NEVER_INLINE void partitionExcessiveAllocationSize()
 {
     IMMEDIATE_CRASH();
 }
 
 static NEVER_INLINE void partitionBucketFull()
 {
@@ skipping 1075 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF