Implement a ScopedThreadHeapUsage class to allow profiling per-thread heap usage.

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"
 #include "base/allocator/features.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/heap_profiler_allocation_register.h"
 #include "base/trace_event/heap_profiler_heap_dump_writer.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <malloc/malloc.h>
 #else
 #include <malloc.h>
 #endif
 
 namespace base {
 namespace trace_event {
 
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
+
 namespace {
 
 using allocator::AllocatorDispatch;
 
 void* HookAlloc(const AllocatorDispatch* self, size_t size) {
   const AllocatorDispatch* const next = self->next;
   void* ptr = next->alloc_function(next, size);
   if (ptr)
     MallocDumpProvider::GetInstance()->InsertAllocation(ptr, size);
   return ptr;
@@ skipping 26 matching lines @@
   return ptr;
 }
 
 void HookFree(const AllocatorDispatch* self, void* address) {
   if (address)
     MallocDumpProvider::GetInstance()->RemoveAllocation(address);
   const AllocatorDispatch* const next = self->next;
   next->free_function(next, address);
 }
 
+size_t HookGetSizeEstimate(const AllocatorDispatch* self, void* address) {

[Primiano Tucci (use gerrit), 2016/08/24 14:11:46]

yeah you don't really need to touch this at all if you use a global function.

[Sigurður Ásgeirsson, 2016/09/01 15:18:18]

Acknowledged.

+  const AllocatorDispatch* const next = self->next;
+  if (!next->get_size_estimate_function)
+    return 0;
+  return next->get_size_estimate_function(next, address);
+}
+
 AllocatorDispatch g_allocator_hooks = {
-    &HookAlloc,         /* alloc_function */
-    &HookZeroInitAlloc, /* alloc_zero_initialized_function */
-    &HookllocAligned,   /* alloc_aligned_function */
-    &HookRealloc,       /* realloc_function */
-    &HookFree,          /* free_function */
-    nullptr,            /* next */
+    &HookAlloc,           /* alloc_function */
+    &HookZeroInitAlloc,   /* alloc_zero_initialized_function */
+    &HookllocAligned,     /* alloc_aligned_function */
+    &HookRealloc,         /* realloc_function */
+    &HookFree,            /* free_function */
+    &HookGetSizeEstimate, /* get_size_estimate_function */
+    nullptr,              /* next */
 };
 
 }  // namespace
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 
 // static
 const char MallocDumpProvider::kAllocatedObjects[] = "malloc/allocated_objects";
 
 // static
 MallocDumpProvider* MallocDumpProvider::GetInstance() {
@@ skipping 155 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