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

base/allocator/allocator_shim.h

Index: base/allocator/allocator_shim.h
diff --git a/base/allocator/allocator_shim.h b/base/allocator/allocator_shim.h
index f1a1e3d7ce0386361480f285cc24f206aee27ac5..53d4f1387faa0a33959a02f95ad521a34c2c4c87 100644
--- a/base/allocator/allocator_shim.h
+++ b/base/allocator/allocator_shim.h
@@ -56,12 +56,19 @@ struct AllocatorDispatch {
                           void* address,
                           size_t size);
   using FreeFn = void(const AllocatorDispatch* self, void* address);
+  // Returns the best available estimate for the actual amount of memory
+  // consumed by the allocation |address|. If possible, this should include
+  // heap overhead or at least a decent estimate of the full cost of the
+  // allocation.

[chrisha, 2016/09/01 20:29:17]

What should implementations do when this isn't possible? Is there a way to
communicate that via this API? Or is it assumed that it will always be possible?

A note that the estimate should be consistent/deterministic? ie. return the same
value for the same inputs?

[Primiano Tucci (use gerrit), 2016/09/02 17:31:20]

Maybe just return 0? IIRC that is the same pattern on POSIX with
malloc_usable_size, where some malloc implementation just return always zero
because they can't be bothered with implementing that :)

[Sigurður Ásgeirsson, 2016/09/06 14:58:53]

Done.

[Sigurður Ásgeirsson, 2016/09/06 14:58:53]

Added mention that zero returns means "dunno".

+  using GetSizeEstimateFn = size_t(const AllocatorDispatch* self,
+                                   void* address);
 
   AllocFn* const alloc_function;
   AllocZeroInitializedFn* const alloc_zero_initialized_function;
   AllocAlignedFn* const alloc_aligned_function;
   ReallocFn* const realloc_function;
   FreeFn* const free_function;
+  GetSizeEstimateFn* const get_size_estimate_function;
 
   const AllocatorDispatch* next;