Hook up allocator shim on mac.

base/trace_event/malloc_dump_provider.cc

 // Copyright 2015 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/trace_event/malloc_dump_provider.h"
 
 #include <stddef.h>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/allocator/allocator_shim.h"
@@ skipping 64 matching lines @@
     MallocDumpProvider::GetInstance()->RemoveAllocation(address);
   const AllocatorDispatch* const next = self->next;
   next->free_function(next, address);
 }
 
 size_t HookGetSizeEstimate(const AllocatorDispatch* self, void* address) {
   const AllocatorDispatch* const next = self->next;
   return next->get_size_estimate_function(next, address);
 }
 
+unsigned HookBatchMalloc(const AllocatorDispatch* self,
+                         size_t size,
+                         void** results,
+                         unsigned num_requested) {
+  const AllocatorDispatch* const next = self->next;
+  unsigned count =
+      next->batch_malloc_function(next, size, results, num_requested);
+  for (unsigned i = 0; i < count; ++i) {
+    MallocDumpProvider::GetInstance()->InsertAllocation(results[i], size);
+  }
+  return count;
+}
+
+void HookBatchFree(const AllocatorDispatch* self,
+                   void** to_be_freed,
+                   unsigned num_to_be_freed) {
+  const AllocatorDispatch* const next = self->next;
+  for (unsigned i = 0; i < num_to_be_freed; ++i) {
+    if (to_be_freed[i] != nullptr) {

[Primiano Tucci (use gerrit), 2017/01/28 05:10:02]

do you know if this will actually happen frequenty or not?
The code of MallocDumpProvider can already tolerate RemoveAllocation(nullptr).
it is not super-smart about it (it will still take the lock and attempt a
hashtable lookup) but won't crash.
So if this is just for paranoid cases, you can avoid this extra check here.

[erikchen, 2017/01/31 02:21:22]

*shrug*, okay. I was just mirroring the format of HookFree.

+      MallocDumpProvider::GetInstance()->RemoveAllocation(to_be_freed[i]);
+    }
+  }
+  next->batch_free_function(next, to_be_freed, num_to_be_freed);
+}
+
 AllocatorDispatch g_allocator_hooks = {
     &HookAlloc,           /* alloc_function */
     &HookZeroInitAlloc,   /* alloc_zero_initialized_function */
     &HookllocAligned,     /* alloc_aligned_function */
     &HookRealloc,         /* realloc_function */
     &HookFree,            /* free_function */
     &HookGetSizeEstimate, /* get_size_estimate_function */
+    &HookBatchMalloc,     /* get_size_estimate_function */
+    &HookBatchFree,       /* get_size_estimate_function */
     nullptr,              /* next */
 };
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 
 #if defined(OS_WIN)
 // A structure containing some information about a given heap.
 struct WinHeapInfo {
   size_t committed_size;
   size_t uncommitted_size;
   size_t allocated_size;
@@ skipping 214 matching lines @@
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base