Hook up allocator shim on mac.

base/debug/thread_heap_usage_tracker.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/thread_heap_usage_tracker.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <new>
 #include <type_traits>
@@ skipping 112 matching lines @@
 void FreeFn(const AllocatorDispatch* self, void* address) {
   if (address != nullptr)
     RecordFree(self->next, address);
   self->next->free_function(self->next, address);
 }
 
 size_t GetSizeEstimateFn(const AllocatorDispatch* self, void* address) {
   return self->next->get_size_estimate_function(self->next, address);
 }
 
+unsigned BatchMallocFn(const AllocatorDispatch* self,
+                       size_t size,
+                       void** results,
+                       unsigned num_requested) {
+  unsigned count = self->next->batch_malloc_function(self->next, size, results,
+                                                     num_requested);
+  for (unsigned i = 0; i < count; ++i) {
+    RecordAlloc(self->next, results[i], size);
+  }
+  return count;
+}
+
+void BatchFreeFn(const AllocatorDispatch* self,
+                 void** to_be_freed,
+                 unsigned num_to_be_freed) {
+  for (unsigned i = 0; i < num_to_be_freed; ++i) {
+    if (to_be_freed[i] != nullptr) {
+      RecordFree(self->next, to_be_freed[i]);
+    }
+  }
+  self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed);
+}
+
+void FreeDefiniteSizeFn(const AllocatorDispatch* self, void* ptr, size_t size) {
+  if (ptr != nullptr)
+    RecordFree(self->next, ptr);
+  self->next->free_definite_size_function(self->next, ptr, size);
+}
+
 // The allocator dispatch used to intercept heap operations.
-AllocatorDispatch allocator_dispatch = {
-    &AllocFn, &AllocZeroInitializedFn, &AllocAlignedFn, &ReallocFn,
-    &FreeFn,  &GetSizeEstimateFn,      nullptr};
+AllocatorDispatch allocator_dispatch = {&AllocFn,
+                                        &AllocZeroInitializedFn,
+                                        &AllocAlignedFn,
+                                        &ReallocFn,
+                                        &FreeFn,
+                                        &GetSizeEstimateFn,
+                                        &BatchMallocFn,
+                                        &BatchFreeFn,
+                                        &FreeDefiniteSizeFn,
+                                        nullptr};
 
 ThreadHeapUsage* GetOrCreateThreadUsage() {
   ThreadHeapUsage* allocator_usage =
       static_cast<ThreadHeapUsage*>(g_thread_allocator_usage.Get());
   if (allocator_usage == kInitializingSentinel)
     return nullptr;  // Re-entrancy case.
 
   if (allocator_usage == nullptr) {
     // Prevent reentrancy due to the allocation below.
     g_thread_allocator_usage.Set(kInitializingSentinel);
@@ skipping 119 matching lines @@
       // heap shim. Otherwise this free will re-initialize the TLS on thread
       // exit.
       allocator_dispatch.next->free_function(allocator_dispatch.next,
                                              allocator_usage);
     });
   }
 }
 
 }  // namespace debug
 }  // namespace base