Hookup the generic heap intercept for Windows.

base/allocator/allocator_shim_default_dispatch_to_winheap.cc

Index: base/allocator/allocator_shim_default_dispatch_to_winheap.cc
diff --git a/base/allocator/allocator_shim_default_dispatch_to_winheap.cc b/base/allocator/allocator_shim_default_dispatch_to_winheap.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4d5a27429a33e16bf18eabc2a432fb2c0882f0eb
--- /dev/null
+++ b/base/allocator/allocator_shim_default_dispatch_to_winheap.cc
@@ -0,0 +1,56 @@
+// 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) {
+  return base::allocator::WinHeapMalloc(size);
+}
+
+void* DefaultWinHeapCallocImpl(const AllocatorDispatch* self,
+                               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 = DefaultWinHeapMallocImpl(self, size);
+  if (result) {
+    memset(result, 0, size);
+  }
+  return result;
+}
+
+void* DefaultWinHeapMemalignImpl(const AllocatorDispatch* self,
+                                 size_t alignment,
+                                 size_t size) {
+  CHECK(false) << "The windows heap does not support memalign.";

[Will Harris, 2016/07/15 15:49:54]

won't this check hit a lot?

[Primiano Tucci (use gerrit), 2016/07/15 17:58:09]

my understand is that memalign is a posix invention, so no code which runs on
windows should be in the state where it can call memalign today.

Now you open an interesting question though. It seems that in windows-land the
alternative is _aligned_malloc. That one doesn't seem shimmed (neither in the
old nor new shim). Is that intentional? Is that because it calls malloc under
the hoods and we intercept it there?

[Sigurður Ásgeirsson, 2016/07/18 19:27:06]

The Win heap doesn't (AFAIK) support aligned allocations, and so _aligned_malloc
requires a matching _aligned_free. Presumably this means these functions
over-allocate from malloc, and prepend the returned memory region with the
distance to the malloc-ed block.
... time passes ... 

Yup, it calls through to malloc.

[Sigurður Ásgeirsson, 2016/07/18 19:27:06]

Nopes, nothing on Windows should call memalign, and there's nothing that
dispatches to this function.

+  return nullptr;
+}
+
+void* DefaultWinHeapReallocImpl(const AllocatorDispatch* self,
+                                void* address,
+                                size_t size) {
+  return base::allocator::WinHeapRealloc(address, size);
+}
+
+void DefaultWinHeapFreeImpl(const AllocatorDispatch*, void* address) {
+  base::allocator::WinHeapFree(address);
+}
+
+}  // namespace
+
+const AllocatorDispatch AllocatorDispatch::default_dispatch = {
+    &DefaultWinHeapMallocImpl,   &DefaultWinHeapCallocImpl,
+    &DefaultWinHeapMemalignImpl, &DefaultWinHeapReallocImpl,
+    &DefaultWinHeapFreeImpl,     nullptr, /* next */
+};