base: Add support for malloc zones to the allocator shim

base/allocator/allocator_shim_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/allocator/allocator_shim.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 41 matching lines @@
 
 class AllocatorShimTest : public testing::Test {
  public:
   static const size_t kMaxSizeTracked = 8192;
   AllocatorShimTest() : testing::Test() {}
 
   static size_t Hash(const void* ptr) {
     return reinterpret_cast<uintptr_t>(ptr) % kMaxSizeTracked;
   }
 
-  static void* MockAlloc(const AllocatorDispatch* self, size_t size) {
+  static void* MockAlloc(const AllocatorDispatch* self,
+                         size_t size,
+                         void* context) {
     if (instance_ && size < kMaxSizeTracked)
       ++(instance_->allocs_intercepted_by_size[size]);
-    return self->next->alloc_function(self->next, size);
+    return self->next->alloc_function(self->next, size, context);
   }
 
   static void* MockAllocZeroInit(const AllocatorDispatch* self,
                                  size_t n,
-                                 size_t size) {
+                                 size_t size,
+                                 void* context) {
     const size_t real_size = n * size;
     if (instance_ && real_size < kMaxSizeTracked)
       ++(instance_->zero_allocs_intercepted_by_size[real_size]);
-    return self->next->alloc_zero_initialized_function(self->next, n, size);
+    return self->next->alloc_zero_initialized_function(self->next, n, size,
+                                                       context);
   }
 
   static void* MockAllocAligned(const AllocatorDispatch* self,
                                 size_t alignment,
-                                size_t size) {
+                                size_t size,
+                                void* context) {
     if (instance_) {
       if (size < kMaxSizeTracked)
         ++(instance_->aligned_allocs_intercepted_by_size[size]);
       if (alignment < kMaxSizeTracked)
         ++(instance_->aligned_allocs_intercepted_by_alignment[alignment]);
     }
-    return self->next->alloc_aligned_function(self->next, alignment, size);
+    return self->next->alloc_aligned_function(self->next, alignment, size,
+                                              context);
   }
 
   static void* MockRealloc(const AllocatorDispatch* self,
                            void* address,
-                           size_t size) {
+                           size_t size,
+                           void* context) {
     if (instance_) {
       // Size 0xFEED a special sentinel for the NewHandlerConcurrency test.
       // Hitting it for the first time will cause a failure, causing the
       // invocation of the std::new_handler.
       if (size == 0xFEED) {
         if (!instance_->did_fail_realloc_0xfeed_once->Get()) {
           instance_->did_fail_realloc_0xfeed_once->Set(true);
           return nullptr;
         } else {
           return address;
         }
       }
 
       if (size < kMaxSizeTracked)
         ++(instance_->reallocs_intercepted_by_size[size]);
       ++instance_->reallocs_intercepted_by_addr[Hash(address)];
     }
-    return self->next->realloc_function(self->next, address, size);
+    return self->next->realloc_function(self->next, address, size, context);
   }
 
-  static void MockFree(const AllocatorDispatch* self, void* address) {
+  static void MockFree(const AllocatorDispatch* self,
+                       void* address,
+                       void* context) {
     if (instance_) {
       ++instance_->frees_intercepted_by_addr[Hash(address)];
     }
-    self->next->free_function(self->next, address);
+    self->next->free_function(self->next, address, context);
   }
 
   static size_t MockGetSizeEstimate(const AllocatorDispatch* self,
-                                    void* address) {
-    return self->next->get_size_estimate_function(self->next, address);
+                                    void* address,
+                                    void* context) {
+    return self->next->get_size_estimate_function(self->next, address, context);
   }
 
   static unsigned MockBatchMalloc(const AllocatorDispatch* self,
                                   size_t size,
                                   void** results,
-                                  unsigned num_requested) {
+                                  unsigned num_requested,
+                                  void* context) {
     if (instance_) {
       instance_->batch_mallocs_intercepted_by_size[size] =
           instance_->batch_mallocs_intercepted_by_size[size] + num_requested;
     }
     return self->next->batch_malloc_function(self->next, size, results,
-                                             num_requested);
+                                             num_requested, context);
   }
 
   static void MockBatchFree(const AllocatorDispatch* self,
                             void** to_be_freed,
-                            unsigned num_to_be_freed) {
+                            unsigned num_to_be_freed,
+                            void* context) {
     if (instance_) {
       for (unsigned i = 0; i < num_to_be_freed; ++i) {
         ++instance_->batch_frees_intercepted_by_addr[Hash(to_be_freed[i])];
       }
     }
-    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);
   }
 
   static void MockFreeDefiniteSize(const AllocatorDispatch* self,
                                    void* ptr,
-                                   size_t size) {
+                                   size_t size,
+                                   void* context) {
     if (instance_) {
       ++instance_->frees_intercepted_by_addr[Hash(ptr)];
       ++instance_->free_definite_sizes_intercepted_by_size[size];
     }
-    self->next->free_definite_size_function(self->next, ptr, size);
+    self->next->free_definite_size_function(self->next, ptr, size, context);
   }
 
   static void NewHandler() {
     if (!instance_)
       return;
     subtle::Barrier_AtomicIncrement(&instance_->num_new_handler_calls, 1);
   }
 
   int32_t GetNumberOfNewHandlerCalls() {
     return subtle::Acquire_Load(&instance_->num_new_handler_calls);
@@ skipping 268 matching lines @@
 
 #if defined(OS_WIN) && BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 TEST_F(AllocatorShimTest, ShimReplacesCRTHeapWhenEnabled) {
   ASSERT_NE(::GetProcessHeap(), reinterpret_cast<HANDLE>(_get_heap_handle()));
 }
 #endif  // defined(OS_WIN) && BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 
 }  // namespace
 }  // namespace allocator
 }  // namespace base