base: Add support for malloc zones to the allocator shim

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 <limits>
 #include <new>
@@ skipping 25 matching lines @@
     reinterpret_cast<ThreadHeapUsage*>(kSentinelMask);
 ThreadHeapUsage* const kTeardownSentinel =
     reinterpret_cast<ThreadHeapUsage*>(kSentinelMask | 1);
 
 bool g_heap_tracking_enabled = false;
 
 // Forward declared as it needs to delegate memory allocation to the next
 // lower shim.
 ThreadHeapUsage* GetOrCreateThreadUsage();
 
-size_t GetAllocSizeEstimate(const AllocatorDispatch* next, void* ptr) {
+size_t GetAllocSizeEstimate(const AllocatorDispatch* next,
+                            void* ptr,
+                            void* context) {
   if (ptr == nullptr)
     return 0U;
 
-  return next->get_size_estimate_function(next, ptr);
+  return next->get_size_estimate_function(next, ptr, context);
 }
 
-void RecordAlloc(const AllocatorDispatch* next, void* ptr, size_t size) {
+void RecordAlloc(const AllocatorDispatch* next,
+                 void* ptr,
+                 size_t size,
+                 void* context) {
   ThreadHeapUsage* usage = GetOrCreateThreadUsage();
   if (usage == nullptr)
     return;
 
   usage->alloc_ops++;
-  size_t estimate = GetAllocSizeEstimate(next, ptr);
+  size_t estimate = GetAllocSizeEstimate(next, ptr, context);
   if (size && estimate) {
     // Only keep track of the net number of bytes allocated in the scope if the
     // size estimate function returns sane values, e.g. non-zero.
     usage->alloc_bytes += estimate;
     usage->alloc_overhead_bytes += estimate - size;
 
     // Record the max outstanding number of bytes, but only if the difference
     // is net positive (e.g. more bytes allocated than freed in the scope).
     if (usage->alloc_bytes > usage->free_bytes) {
       uint64_t allocated_bytes = usage->alloc_bytes - usage->free_bytes;
       if (allocated_bytes > usage->max_allocated_bytes)
         usage->max_allocated_bytes = allocated_bytes;
     }
   } else {
     usage->alloc_bytes += size;
   }
 }
 
-void RecordFree(const AllocatorDispatch* next, void* ptr) {
+void RecordFree(const AllocatorDispatch* next, void* ptr, void* context) {
   ThreadHeapUsage* usage = GetOrCreateThreadUsage();
   if (usage == nullptr)
     return;
 
-  size_t estimate = GetAllocSizeEstimate(next, ptr);
+  size_t estimate = GetAllocSizeEstimate(next, ptr, context);
   usage->free_ops++;
   usage->free_bytes += estimate;
 }
 
-void* AllocFn(const AllocatorDispatch* self, size_t size) {
-  void* ret = self->next->alloc_function(self->next, size);
+void* AllocFn(const AllocatorDispatch* self, size_t size, void* context) {
+  void* ret = self->next->alloc_function(self->next, size, context);
   if (ret != nullptr)
-    RecordAlloc(self->next, ret, size);
+    RecordAlloc(self->next, ret, size, context);
 
   return ret;
 }
 
 void* AllocZeroInitializedFn(const AllocatorDispatch* self,
                              size_t n,
-                             size_t size) {
-  void* ret = self->next->alloc_zero_initialized_function(self->next, n, size);
+                             size_t size,
+                             void* context) {
+  void* ret =
+      self->next->alloc_zero_initialized_function(self->next, n, size, context);
   if (ret != nullptr)
-    RecordAlloc(self->next, ret, size);
+    RecordAlloc(self->next, ret, size, context);
 
   return ret;
 }
 
 void* AllocAlignedFn(const AllocatorDispatch* self,
                      size_t alignment,
-                     size_t size) {
-  void* ret = self->next->alloc_aligned_function(self->next, alignment, size);
+                     size_t size,
+                     void* context) {
+  void* ret =
+      self->next->alloc_aligned_function(self->next, alignment, size, context);
   if (ret != nullptr)
-    RecordAlloc(self->next, ret, size);
+    RecordAlloc(self->next, ret, size, context);
 
   return ret;
 }
 
-void* ReallocFn(const AllocatorDispatch* self, void* address, size_t size) {
+void* ReallocFn(const AllocatorDispatch* self,
+                void* address,
+                size_t size,
+                void* context) {
   if (address != nullptr)
-    RecordFree(self->next, address);
+    RecordFree(self->next, address, context);
 
-  void* ret = self->next->realloc_function(self->next, address, size);
+  void* ret = self->next->realloc_function(self->next, address, size, context);
   if (ret != nullptr && size != 0)
-    RecordAlloc(self->next, ret, size);
+    RecordAlloc(self->next, ret, size, context);
 
   return ret;
 }
 
-void FreeFn(const AllocatorDispatch* self, void* address) {
+void FreeFn(const AllocatorDispatch* self, void* address, void* context) {
   if (address != nullptr)
-    RecordFree(self->next, address);
-  self->next->free_function(self->next, address);
+    RecordFree(self->next, address, context);
+  self->next->free_function(self->next, address, context);
 }
 
-size_t GetSizeEstimateFn(const AllocatorDispatch* self, void* address) {
-  return self->next->get_size_estimate_function(self->next, address);
+size_t GetSizeEstimateFn(const AllocatorDispatch* self,
+                         void* address,
+                         void* context) {
+  return self->next->get_size_estimate_function(self->next, address, context);
 }
 
 unsigned BatchMallocFn(const AllocatorDispatch* self,
                        size_t size,
                        void** results,
-                       unsigned num_requested) {
+                       unsigned num_requested,
+                       void* context) {
   unsigned count = self->next->batch_malloc_function(self->next, size, results,
-                                                     num_requested);
+                                                     num_requested, context);
   for (unsigned i = 0; i < count; ++i) {
-    RecordAlloc(self->next, results[i], size);
+    RecordAlloc(self->next, results[i], size, context);
   }
   return count;
 }
 
 void BatchFreeFn(const AllocatorDispatch* self,
                  void** to_be_freed,
-                 unsigned num_to_be_freed) {
+                 unsigned num_to_be_freed,
+                 void* context) {
   for (unsigned i = 0; i < num_to_be_freed; ++i) {
     if (to_be_freed[i] != nullptr) {
-      RecordFree(self->next, to_be_freed[i]);
+      RecordFree(self->next, to_be_freed[i], context);
     }
   }
-  self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed);
+  self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed,
+                                  context);
 }
 
-void FreeDefiniteSizeFn(const AllocatorDispatch* self, void* ptr, size_t size) {
+void FreeDefiniteSizeFn(const AllocatorDispatch* self,
+                        void* ptr,
+                        size_t size,
+                        void* context) {
   if (ptr != nullptr)
-    RecordFree(self->next, ptr);
-  self->next->free_definite_size_function(self->next, ptr, size);
+    RecordFree(self->next, ptr, context);
+  self->next->free_definite_size_function(self->next, ptr, size, context);
 }
 
 // The allocator dispatch used to intercept heap operations.
 AllocatorDispatch allocator_dispatch = {&AllocFn,
                                         &AllocZeroInitializedFn,
                                         &AllocAlignedFn,
                                         &ReallocFn,
                                         &FreeFn,
                                         &GetSizeEstimateFn,
                                         &BatchMallocFn,
@@ skipping 137 matching lines @@
       // RecordFree() above. The sentinel prevents RecordFree() from re-creating
       // another ThreadHeapUsage object.
       g_thread_allocator_usage.Set(kTeardownSentinel);
       delete static_cast<ThreadHeapUsage*>(thread_heap_usage);
     });
   }
 }
 
 }  // namespace debug
 }  // namespace base