Hookup the generic heap intercept for Windows.

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 <unistd.h>
 
 #include <memory>
 #include <new>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#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);
 }
 #endif
 
 namespace base {
@@ skipping 128 matching lines @@
     void* res = realloc(reinterpret_cast<void*>(0x420ul), 1);
     EXPECT_EQ(reinterpret_cast<void*>(0x420ul), res);
   }
 
  private:
   WaitableEvent* event_;
 };
 
 AllocatorShimTest* AllocatorShimTest::instance_ = nullptr;
 
+inline size_t GetPageSize() {

[Primiano Tucci (use gerrit), 2016/07/12 14:51:05]

I think you can use GetPageSize() from base/procesS_metrics.h here

[Sigurður Ásgeirsson, 2016/07/14 19:04:27]

Done.

I wonder if it's safe to use it also in allocator_shim.cc? I'd worry about
reentrancy?

[Primiano Tucci (use gerrit), 2016/07/15 14:02:10]

the main reason why I didn't use it straight there is because on Linux, it
involves doing a sysconf syscall, while my impl does the caching (and its
inlined). Not a huge deal for the unittest but can be a perf bummer on Linux.

You could probably just rework the one in shim.cc to always do the caching (Even
if useless on Windows) and just use GetPageSize(). 
The current impl look safe to me.

+#if defined(OS_WIN)
+  return 4096;
+#else
+  static size_t pagesize = 0;
+  if (!pagesize)
+    pagesize = sysconf(_SC_PAGESIZE);
+  return pagesize;
+#endif
+}
+
 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 */
     nullptr,                               /* next */
 };
 
 TEST_F(AllocatorShimTest, InterceptLibcSymbols) {
-  const size_t kPageSize = sysconf(_SC_PAGESIZE);
+  const size_t kPageSize = GetPageSize();
   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)
   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* 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);
   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);
 
   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);
   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(realloc_ptr)], 1u);
+  ASSERT_GE(reallocs_intercepted_by_addr[Hash(old_realloc_ptr)], 1u);

[Primiano Tucci (use gerrit), 2016/07/12 14:51:05]

uh?

[Sigurður Ásgeirsson, 2016/07/14 19:04:27]

The test fixture records the inbound pointer to the realloc. If the pointer is
truly reallocated, then this test fails. This is happening under the WinHeap,
presumably because 71->73 jumps a size class in the WinHeap, whereas the other
allocators are eating slop in the original allocation.
The test is strictly speaking incorrect, as-is.

[Primiano Tucci (use gerrit), 2016/07/15 14:02:10]

Ahh I see. makes sense. Thanks.

   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)
   free(memalign_ptr);
   ASSERT_GE(frees_intercepted_by_addr[Hash(memalign_ptr)], 1u);
 
   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
 
   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 60 matching lines @@
   event.Signal();
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Join(threads[i]);
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
   ASSERT_EQ(kNumThreads, GetNumberOfNewHandlerCalls());
 }
 
 }  // namespace
 }  // namespace allocator
 }  // namespace base