Hook up allocator shim on mac.

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"
+#include "build/build_config.h"
 
 namespace base {
 namespace allocator {
 
 // Allocator Shim API. Allows to to:
 //  - Configure the behavior of the allocator (what to do on OOM failures).
 //  - Install new hooks (AllocatorDispatch) in the allocator chain.
 
 // When this shim layer is enabled, the route of an allocation is as-follows:
 //
@@ skipping 34 matching lines @@
   using ReallocFn = void*(const AllocatorDispatch* self,
                           void* address,
                           size_t size);
   using FreeFn = void(const AllocatorDispatch* self, void* address);
   // 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);
+  using BatchMallocFn = unsigned(const AllocatorDispatch* self,
+                                 size_t size,
+                                 void** results,
+                                 unsigned num_requested);
+  using BatchFreeFn = void(const AllocatorDispatch* self,
+                           void** to_be_freed,
+                           unsigned num_to_be_freed);
+  using FreeDefiniteSizeFn = void(const AllocatorDispatch* self,
+                                  void* ptr,
+                                  size_t size);
 
   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;
 
   const AllocatorDispatch* next;
 
   // |default_dispatch| is statically defined by one (and only one) of the
   // allocator_shim_default_dispatch_to_*.cc files, depending on the build
   // configuration.
   static const AllocatorDispatch default_dispatch;
 };
 
 // When true makes malloc behave like new, w.r.t calling the new_handler if
 // the allocation fails (see set_new_mode() in Windows).
 BASE_EXPORT void SetCallNewHandlerOnMallocFailure(bool value);
 
 // Allocates |size| bytes or returns nullptr. It does NOT call the new_handler,
 // regardless of SetCallNewHandlerOnMallocFailure().
 BASE_EXPORT void* UncheckedAlloc(size_t size);
 
 // Inserts |dispatch| in front of the allocator chain. This method is
 // thread-safe w.r.t concurrent invocations of InsertAllocatorDispatch().
 // The callers have responsibility for inserting a single dispatch no more
 // than once.
 BASE_EXPORT void InsertAllocatorDispatch(AllocatorDispatch* dispatch);
 
 // Test-only. Rationale: (1) lack of use cases; (2) dealing safely with a
 // removal of arbitrary elements from a singly linked list would require a lock
 // in malloc(), which we really don't want.
 BASE_EXPORT void RemoveAllocatorDispatchForTesting(AllocatorDispatch* dispatch);
 
+#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_