Hookup the generic heap intercept for Windows.

base/allocator/allocator_impl_win.cc

Index: base/allocator/allocator_impl_win.cc
diff --git a/base/allocator/allocator_impl_win.cc b/base/allocator/allocator_impl_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f86ef18b206e0a9831d3d5229ce86166c7a199fd
--- /dev/null
+++ b/base/allocator/allocator_impl_win.cc
@@ -0,0 +1,83 @@
+// Copyright (c) 2012 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 <limits.h>
+#include <malloc.h>
+#include <new.h>
+#include <windows.h>
+#include <stddef.h>
+
+#include "allocator_impl_win.h"
+#include "allocator_impl_win.h"
+
+namespace base {
+namespace allocator {
+
+bool g_is_win_shim_layer_initialized = false;
+
+namespace {
+
+const size_t kWindowsPageSize = 4096;
+const size_t kMaxWindowsAllocation = INT_MAX - kWindowsPageSize;
+
+inline HANDLE get_heap_handle() {
+  return reinterpret_cast<HANDLE>(_get_heap_handle());
+}
+
+}  // namespace
+
+void* WinHeapMalloc(size_t size) {

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

I wonder if all these should be inline functions in the .h file, or if the perf
hit about this extra call will be noticed. At the end they will be called by
just two places until we have both shims, and at the end we'll merge this file
into the deault dispatch

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

In practice this won't matter for the official builds, as the MSVC compiler will
do cross-module inlining with link-time-code generation. I have no preference,
happy to move these if you prefer?

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

SG leaving them as they are. Will see if the perf bots shout and come back here
if they do :)

+  if (size < kMaxWindowsAllocation)
+    return HeapAlloc(get_heap_handle(), 0, size);
+  return nullptr;
+}
+
+void WinHeapFree(void* size) {
+  HeapFree(get_heap_handle(), 0, size);
+}
+
+void* WinHeapRealloc(void* ptr, size_t size) {
+  if (!ptr)
+    return WinHeapMalloc(size);
+  if (!size) {
+    WinHeapFree(ptr);
+    return nullptr;
+  }
+  if (size < kMaxWindowsAllocation)
+    return HeapReAlloc(get_heap_handle(), 0, ptr, size);
+  return nullptr;
+}
+
+void* WinHeapCalloc(size_t n, size_t elem_size) {
+  // Overflow check.
+  const size_t size = n * elem_size;
+  if (elem_size != 0 && size / elem_size != n)
+    return nullptr;
+
+  void* result = WinHeapMalloc(size);
+  if (result) {
+    memset(result, 0, size);
+  }
+  return result;
+}
+
+// Call the new handler, if one has been set.
+// Returns true on successfully calling the handler, false otherwise.
+bool WinCallNewHandler(size_t size) {
+  // Get the current new handler.
+  _PNH nh = _query_new_handler();
+#if defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
+  if (!nh)
+    return false;
+  // Since exceptions are disabled, we don't really know if new_handler
+  // failed.  Assume it will abort if it fails.
+  return nh(size) ? true : false;
+#else
+#error "Exceptions in allocator shim are not supported!"
+#endif  // defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
+
+}
+
+}  // namespace allocator
+}  // namespace base}