base: Add support for malloc zones to the allocator shim

base/allocator/allocator_shim.h

 // 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.
 
 #ifndef BASE_ALLOCATOR_ALLOCATOR_SHIM_H_
 #define BASE_ALLOCATOR_ALLOCATOR_SHIM_H_
 
 #include <stddef.h>
 
 #include "base/base_export.h"
@@ skipping 28 matching lines @@
 //   config (tcmalloc, glibc, ...).
 //
 // It is possible to dynamically insert further AllocatorDispatch stages
 // to the front of the chain, for debugging / profiling purposes.
 //
 // All the functions must be thred safe. The shim does not enforce any
 // serialization. This is to route to thread-aware allocators (e.g, tcmalloc)
 // wihout introducing unnecessary perf hits.
 
 struct AllocatorDispatch {
-  using AllocFn = void*(const AllocatorDispatch* self, size_t size);
+  using AllocFn = void*(const AllocatorDispatch* self,
+                        size_t size,
+                        void* context);
   using AllocZeroInitializedFn = void*(const AllocatorDispatch* self,
                                        size_t n,
-                                       size_t size);
+                                       size_t size,
+                                       void* context);
   using AllocAlignedFn = void*(const AllocatorDispatch* self,
                                size_t alignment,
-                               size_t size);
+                               size_t size,
+                               void* context);
   using ReallocFn = void*(const AllocatorDispatch* self,
                           void* address,
-                          size_t size);
-  using FreeFn = void(const AllocatorDispatch* self, void* address);
+                          size_t size,
+                          void* context);
+  using FreeFn = void(const AllocatorDispatch* self,
+                      void* address,
+                      void* context);
   // 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. If no good estimate is possible, returns zero.
   using GetSizeEstimateFn = size_t(const AllocatorDispatch* self,
-                                   void* address);
+                                   void* address,
+                                   void* context);
   using BatchMallocFn = unsigned(const AllocatorDispatch* self,
                                  size_t size,
                                  void** results,
-                                 unsigned num_requested);
+                                 unsigned num_requested,
+                                 void* context);
   using BatchFreeFn = void(const AllocatorDispatch* self,
                            void** to_be_freed,
-                           unsigned num_to_be_freed);
+                           unsigned num_to_be_freed,
+                           void* context);
   using FreeDefiniteSizeFn = void(const AllocatorDispatch* self,
                                   void* ptr,
-                                  size_t size);
+                                  size_t size,
+                                  void* context);
 
   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;
   BatchMallocFn* const batch_malloc_function;
   BatchFreeFn* const batch_free_function;
   FreeDefiniteSizeFn* const free_definite_size_function;
@@ skipping 27 matching lines @@
 
 #if defined(OS_MACOSX)
 // On macOS, the allocator shim needs to be turned on during runtime.
 BASE_EXPORT void InitializeAllocatorShim();
 #endif  // defined(OS_MACOSX)
 
 }  // namespace allocator
 }  // namespace base
 
 #endif  // BASE_ALLOCATOR_ALLOCATOR_SHIM_H_