[NOT FOR REVIEW] Basic allocator shim for macOS.

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 <malloc.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 #include <new>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/process/process_metrics.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
+#include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_MACOSX)
+#include <malloc/malloc.h>
+#else
+#include <malloc.h>
+#endif
+
 #if !defined(OS_WIN)
 #include <unistd.h>
 #endif
 
 // Some new Android NDKs (64 bit) does not expose (p)valloc anymore. These
 // functions are implemented at the shim-layer level.
 #if defined(OS_ANDROID)
 extern "C" {
 void* valloc(size_t size);
 void* pvalloc(size_t size);
@@ skipping 66 matching lines @@
     return self->next->realloc_function(self->next, address, size);
   }
 
   static void MockFree(const AllocatorDispatch* self, void* address) {
     if (instance_) {
       ++instance_->frees_intercepted_by_addr[Hash(address)];
     }
     self->next->free_function(self->next, address);
   }
 
+  static size_t MockGetSizeEstimate(const AllocatorDispatch* self,
+                                    void* address) {
+    return self->next->get_size_estimate_function(self->next, address);
+  }
+
   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 52 matching lines @@
 };
 
 AllocatorShimTest* AllocatorShimTest::instance_ = nullptr;
 
 AllocatorDispatch g_mock_dispatch = {
     &AllocatorShimTest::MockAlloc,         /* alloc_function */
     &AllocatorShimTest::MockAllocZeroInit, /* alloc_zero_initialized_function */
     &AllocatorShimTest::MockAllocAligned,  /* alloc_aligned_function */
     &AllocatorShimTest::MockRealloc,       /* realloc_function */
     &AllocatorShimTest::MockFree,          /* free_function */
+    &AllocatorShimTest::MockGetSizeEstimate,/* get_size_estimate_function */
     nullptr,                               /* next */
 };
 
 TEST_F(AllocatorShimTest, InterceptLibcSymbols) {
+  realloc(nullptr, 9);
+
   InsertAllocatorDispatch(&g_mock_dispatch);
 
   void* alloc_ptr = malloc(19);
   ASSERT_NE(nullptr, alloc_ptr);
   ASSERT_GE(allocs_intercepted_by_size[19], 1u);
 
   void* zero_alloc_ptr = calloc(2, 23);
   ASSERT_NE(nullptr, zero_alloc_ptr);
   ASSERT_GE(zero_allocs_intercepted_by_size[2 * 23], 1u);
 
-#if !defined(OS_WIN)
+#if !defined(OS_WIN) && !defined(OS_MACOSX)
   void* memalign_ptr = memalign(128, 53);
   ASSERT_NE(nullptr, memalign_ptr);
   ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(memalign_ptr) % 128);
   ASSERT_GE(aligned_allocs_intercepted_by_alignment[128], 1u);
   ASSERT_GE(aligned_allocs_intercepted_by_size[53], 1u);
 
+  void* pvalloc_ptr = pvalloc(67);
+  ASSERT_NE(nullptr, pvalloc_ptr);
+  ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(pvalloc_ptr) % kPageSize);
+  ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u);
+  // pvalloc rounds the size up to the next page.
+  ASSERT_GE(aligned_allocs_intercepted_by_size[kPageSize], 1u);
+#endif  // !OS_WIN && !OS_MACOSX
+
+#if !defined(OS_WIN)
   void* posix_memalign_ptr = nullptr;
   int res = posix_memalign(&posix_memalign_ptr, 256, 59);
   ASSERT_EQ(0, res);
   ASSERT_NE(nullptr, posix_memalign_ptr);
   ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(posix_memalign_ptr) % 256);
   ASSERT_GE(aligned_allocs_intercepted_by_alignment[256], 1u);
   ASSERT_GE(aligned_allocs_intercepted_by_size[59], 1u);
 
   void* valloc_ptr = valloc(61);
   ASSERT_NE(nullptr, valloc_ptr);
   const size_t kPageSize = base::GetPageSize();
   ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(valloc_ptr) % kPageSize);
   ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u);
   ASSERT_GE(aligned_allocs_intercepted_by_size[61], 1u);
+#endif  // !OS_WIN
 
-  void* pvalloc_ptr = pvalloc(67);
-  ASSERT_NE(nullptr, pvalloc_ptr);
-  ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(pvalloc_ptr) % kPageSize);
-  ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u);
-  // pvalloc rounds the size up to the next page.
-  ASSERT_GE(aligned_allocs_intercepted_by_size[kPageSize], 1u);
-#endif  // OS_WIN
-
-  char* realloc_ptr = static_cast<char*>(realloc(nullptr, 71));
-  ASSERT_NE(nullptr, realloc_ptr);
-  ASSERT_GE(reallocs_intercepted_by_size[71], 1u);
-  ASSERT_GE(reallocs_intercepted_by_addr[Hash(nullptr)], 1u);
+  char* realloc_ptr = static_cast<char*>(malloc(10));
   strcpy(realloc_ptr, "foobar");
   void* old_realloc_ptr = realloc_ptr;
   realloc_ptr = static_cast<char*>(realloc(realloc_ptr, 73));
   ASSERT_GE(reallocs_intercepted_by_size[73], 1u);
   ASSERT_GE(reallocs_intercepted_by_addr[Hash(old_realloc_ptr)], 1u);
   ASSERT_EQ(0, strcmp(realloc_ptr, "foobar"));
 
   free(alloc_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(alloc_ptr)], 1u);
 
   free(zero_alloc_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(zero_alloc_ptr)], 1u);
 
-#if !defined(OS_WIN)
+#if !defined(OS_WIN) && !defined(OS_MACOSX)
   free(memalign_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(memalign_ptr)], 1u);
 
+  free(pvalloc_ptr);
+  ASSERT_GE(frees_intercepted_by_addr[Hash(pvalloc_ptr)], 1u);
+#endif  // !OS_WIN && !OS_MACOSX
+
+#if !defined(OS_WIN)
   free(posix_memalign_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(posix_memalign_ptr)], 1u);
 
   free(valloc_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(valloc_ptr)], 1u);
-
-  free(pvalloc_ptr);
-  ASSERT_GE(frees_intercepted_by_addr[Hash(pvalloc_ptr)], 1u);
-#endif  // OS_WIN
+#endif  // !OS_WIN
 
   free(realloc_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(realloc_ptr)], 1u);
 
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
 
   void* non_hooked_ptr = malloc(4095);
   ASSERT_NE(nullptr, non_hooked_ptr);
   ASSERT_EQ(0u, allocs_intercepted_by_size[4095]);
   free(non_hooked_ptr);
@@ skipping 26 matching lines @@
 
   delete new_nt_ptr;
   ASSERT_GE(frees_intercepted_by_addr[Hash(new_nt_ptr)], 1u);
 
   delete[] new_array_nt_ptr;
   ASSERT_GE(frees_intercepted_by_addr[Hash(new_array_nt_ptr)], 1u);
 
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
 }
 
+#if !defined(OS_MACOSX)
+
+/*
+  realloc() on macOS tries to find zone from ptr and asserts when that fails on
+  bogus value 0x420 we're using:
+
+  base_unittests(54335,0x70000da6e000) malloc: *** error for object 0x420: pointer being realloc'd was not allocated
+
+  See realloc() implementation in libSystem.
+*/
+
 // This test exercises the case of concurrent OOM failure, which would end up
 // invoking std::new_handler concurrently. This is to cover the CallNewHandler()
 // paths of allocator_shim.cc and smoke-test its thread safey.
 // The test creates kNumThreads threads. Each of them does just a
 // realloc(0x420).
 // The shim intercepts such realloc and makes it fail only once on each thread.
 // We expect to see excactly kNumThreads invocations of the new_handler.
 TEST_F(AllocatorShimTest, NewHandlerConcurrency) {
   const int kNumThreads = 32;
   PlatformThreadHandle threads[kNumThreads];
@@ skipping 11 matching lines @@
   std::set_new_handler(&AllocatorShimTest::NewHandler);
   SetCallNewHandlerOnMallocFailure(true);  // It's going to fail on realloc().
   InsertAllocatorDispatch(&g_mock_dispatch);
   event.Signal();
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Join(threads[i]);
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
   ASSERT_EQ(kNumThreads, GetNumberOfNewHandlerCalls());
 }
 
+#endif
+
 }  // namespace
 }  // namespace allocator
 }  // namespace base