Roll Chrome into Mojo.

base/process/memory_win.cc

 // Copyright (c) 2013 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/process/memory.h"
 
+#include <new.h>
 #include <psapi.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace base {
 
 namespace {
 
-void OnNoMemory() {
-  // Kill the process. This is important for security, since WebKit doesn't
-  // NULL-check many memory allocations. If a malloc fails, returns NULL, and
-  // the buffer is then used, it provides a handy mapping of memory starting at
-  // address 0 for an attacker to utilize.
+#pragma warning(push)
+#pragma warning(disable: 4702)
+
+int OnNoMemory(size_t) {
+  // Kill the process. This is important for security since most of code
+  // does not check the result of memory allocation.
   __debugbreak();
   _exit(1);
+  return 0;
 }
 
+#pragma warning(pop)
+
 // HeapSetInformation function pointer.
 typedef BOOL (WINAPI* HeapSetFn)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
 
 }  // namespace
 
 bool EnableLowFragmentationHeap() {
   HMODULE kernel32 = GetModuleHandle(L"kernel32.dll");
   HeapSetFn heap_set = reinterpret_cast<HeapSetFn>(GetProcAddress(
       kernel32,
       "HeapSetInformation"));
@@ skipping 26 matching lines @@
   }
   return true;
 }
 
 void EnableTerminationOnHeapCorruption() {
   // Ignore the result code. Supported on XP SP3 and Vista.
   HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
 }
 
 void EnableTerminationOnOutOfMemory() {
-  std::set_new_handler(&OnNoMemory);
+  _set_new_handler(&OnNoMemory);
+  _set_new_mode(1);
 }
 
 HMODULE GetModuleFromAddress(void* address) {
   HMODULE instance = NULL;
   if (!::GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                             GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                             static_cast<char*>(address),
                             &instance)) {
     NOTREACHED();
   }
   return instance;
 }
 
 // TODO(b.kelemen): implement it with the required semantics. On Linux this is
 // implemented with a weak symbol that is overridden by tcmalloc. This is
 // neccessary because base cannot have a direct dependency on tcmalloc. Since
 // weak symbols are not supported on Windows this will involve some build time
 // magic, much like what is done for libcrt in order to override the allocation
 // functions.
 bool UncheckedMalloc(size_t size, void** result) {
   *result = malloc(size);
   return *result != NULL;
 }
 
 }  // namespace base