Start refactoring Windows allocator shim in prep for hooking in generic allocator shim on Windows.

base/allocator/winheap_stubs_win.cc

Index: base/allocator/winheap_stubs_win.cc
diff --git a/base/allocator/winheap_stubs_win.cc b/base/allocator/winheap_stubs_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cb197b21a0061bf60137c09f891ee2597d2723a0
--- /dev/null
+++ b/base/allocator/winheap_stubs_win.cc
@@ -0,0 +1,84 @@
+// 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.
+
+// This code should move into the default Windows shim once the win-specific
+// allocation shim has been removed, and the generic shim has becaome the
+// default.
+
+#include "winheap_stubs_win.h"
+
+#include <limits.h>
+#include <malloc.h>
+#include <new.h>
+#include <windows.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) {
+  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) {

[Primiano Tucci (use gerrit), 2016/07/13 17:42:49]

Not sure you need this here. This function is not used by the old shim (and I
think what you are doing is correct). But this suggests that in the next CL you
can just put this body inside the dispatch_to_winheap.cc

[Sigurður Ásgeirsson, 2016/07/13 18:47:45]

Removed, thanks.

+  // 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) {

[Will Harris, 2016/07/13 18:10:37]

this function might need to be added to the "functions to ignore when trying to
work out correct bucket in crash"

go/link_for_2143693003

[Sigurður Ásgeirsson, 2016/07/13 18:47:45]

Acknowledged.

+  // 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