base: Add support for malloc zones to the allocator shim

base/allocator/allocator_shim_default_dispatch_to_winheap.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 "base/allocator/winheap_stubs_win.h"
 #include "base/logging.h"
 
 namespace {
 
 using base::allocator::AllocatorDispatch;
 
-void* DefaultWinHeapMallocImpl(const AllocatorDispatch*, size_t size) {
+void* DefaultWinHeapMallocImpl(const AllocatorDispatch*,
+                               size_t size,
+                               void* context) {
   return base::allocator::WinHeapMalloc(size);
 }
 
 void* DefaultWinHeapCallocImpl(const AllocatorDispatch* self,
                                size_t n,
-                               size_t elem_size) {
+                               size_t elem_size,
+                               void* context) {
   // Overflow check.
   const size_t size = n * elem_size;
   if (elem_size != 0 && size / elem_size != n)
     return nullptr;
 
-  void* result = DefaultWinHeapMallocImpl(self, size);
+  void* result = DefaultWinHeapMallocImpl(self, size, context);
   if (result) {
     memset(result, 0, size);
   }
   return result;
 }
 
 void* DefaultWinHeapMemalignImpl(const AllocatorDispatch* self,
                                  size_t alignment,
-                                 size_t size) {
+                                 size_t size,
+                                 void* context) {
   CHECK(false) << "The windows heap does not support memalign.";
   return nullptr;
 }
 
 void* DefaultWinHeapReallocImpl(const AllocatorDispatch* self,
                                 void* address,
-                                size_t size) {
+                                size_t size,
+                                void* context) {
   return base::allocator::WinHeapRealloc(address, size);
 }
 
-void DefaultWinHeapFreeImpl(const AllocatorDispatch*, void* address) {
+void DefaultWinHeapFreeImpl(const AllocatorDispatch*,
+                            void* address,
+                            void* context) {
   base::allocator::WinHeapFree(address);
 }
 
 size_t DefaultWinHeapGetSizeEstimateImpl(const AllocatorDispatch*,
-                                         void* address) {
+                                         void* address,
+                                         void* context) {
   return base::allocator::WinHeapGetSizeEstimate(address);
 }
 
 }  // namespace
 
 const AllocatorDispatch AllocatorDispatch::default_dispatch = {
     &DefaultWinHeapMallocImpl,
     &DefaultWinHeapCallocImpl,
     &DefaultWinHeapMemalignImpl,
     &DefaultWinHeapReallocImpl,
     &DefaultWinHeapFreeImpl,
     &DefaultWinHeapGetSizeEstimateImpl,
     nullptr, /* batch_malloc_function */
     nullptr, /* batch_free_function */
     nullptr, /* free_definite_size_function */
     nullptr, /* next */
 };