base: Add support for malloc zones to the allocator shim

base/debug/thread_heap_usage_tracker_unittest.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 <map>
 
 #include "base/allocator/allocator_shim.h"
 #include "base/allocator/features.h"
@@ skipping 50 matching lines @@
     dispatch_under_test_->next = &g_mock_dispatch;
   }
 
   void TearDown() override {
     ASSERT_EQ(&g_mock_dispatch, dispatch_under_test_->next);
 
     dispatch_under_test_->next = nullptr;
   }
 
   void* MockMalloc(size_t size) {
-    return dispatch_under_test_->alloc_function(dispatch_under_test_, size);
+    return dispatch_under_test_->alloc_function(dispatch_under_test_, size,
+                                                nullptr);
   }
 
   void* MockCalloc(size_t n, size_t size) {
     return dispatch_under_test_->alloc_zero_initialized_function(
-        dispatch_under_test_, n, size);
+        dispatch_under_test_, n, size, nullptr);
   }
 
   void* MockAllocAligned(size_t alignment, size_t size) {
-    return dispatch_under_test_->alloc_aligned_function(dispatch_under_test_,
-                                                        alignment, size);
+    return dispatch_under_test_->alloc_aligned_function(
+        dispatch_under_test_, alignment, size, nullptr);
   }
 
   void* MockRealloc(void* address, size_t size) {
     return dispatch_under_test_->realloc_function(dispatch_under_test_, address,
-                                                  size);
+                                                  size, nullptr);
   }
 
   void MockFree(void* address) {
-    dispatch_under_test_->free_function(dispatch_under_test_, address);
+    dispatch_under_test_->free_function(dispatch_under_test_, address, nullptr);
   }
 
   size_t MockGetSizeEstimate(void* address) {
     return dispatch_under_test_->get_size_estimate_function(
-        dispatch_under_test_, address);
+        dispatch_under_test_, address, nullptr);
   }
 
  private:
   void RecordAlloc(void* address, size_t size) {
     if (address != nullptr)
       allocation_size_map_[address] = size;
   }
 
   void DeleteAlloc(void* address) {
     if (address != nullptr)
@@ skipping 13 matching lines @@
         ret += kAllocationPadding;
         break;
       case ZERO_SIZE_FUNCTION:
         ret = 0;
         break;
     }
 
     return ret;
   }
 
-  static void* OnAllocFn(const AllocatorDispatch* self, size_t size) {
+  static void* OnAllocFn(const AllocatorDispatch* self,
+                         size_t size,
+                         void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     void* ret = malloc(size);
     g_self->RecordAlloc(ret, size);
     return ret;
   }
 
   static void* OnAllocZeroInitializedFn(const AllocatorDispatch* self,
                                         size_t n,
-                                        size_t size) {
+                                        size_t size,
+                                        void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     void* ret = calloc(n, size);
     g_self->RecordAlloc(ret, n * size);
     return ret;
   }
 
   static void* OnAllocAlignedFn(const AllocatorDispatch* self,
                                 size_t alignment,
-                                size_t size) {
+                                size_t size,
+                                void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     // This is a cheat as it doesn't return aligned allocations. This has the
     // advantage of working for all platforms for this test.
     void* ret = malloc(size);
     g_self->RecordAlloc(ret, size);
     return ret;
   }
 
   static void* OnReallocFn(const AllocatorDispatch* self,
                            void* address,
-                           size_t size) {
+                           size_t size,
+                           void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     g_self->DeleteAlloc(address);
     void* ret = realloc(address, size);
     g_self->RecordAlloc(ret, size);
     return ret;
   }
 
-  static void OnFreeFn(const AllocatorDispatch* self, void* address) {
+  static void OnFreeFn(const AllocatorDispatch* self,
+                       void* address,
+                       void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     g_self->DeleteAlloc(address);
     free(address);
   }
 
   static size_t OnGetSizeEstimateFn(const AllocatorDispatch* self,
-                                    void* address) {
+                                    void* address,
+                                    void* context) {
     EXPECT_EQ(&g_mock_dispatch, self);
 
     return g_self->GetSizeEstimate(address);
   }
 
   using AllocationSizeMap = std::map<void*, size_t>;
 
   SizeFunctionKind size_function_kind_;
   AllocationSizeMap allocation_size_map_;
   AllocatorDispatch* dispatch_under_test_;
@@ skipping 393 matching lines @@
   EXPECT_LE(u2.free_ops + 1, u3.free_ops);
 
   TestingThreadHeapUsageTracker::DisableHeapTrackingForTesting();
 
   ASSERT_FALSE(ThreadHeapUsageTracker::IsHeapTrackingEnabled());
 }
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 
 }  // namespace debug
 }  // namespace base