Update from https://crrev.com/327068

base/process/memory_mac.mm

 // 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 <CoreFoundation/CoreFoundation.h>
 #include <errno.h>
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
@@ skipping 113 matching lines @@
 calloc_type g_old_calloc_purgeable;
 valloc_type g_old_valloc_purgeable;
 free_type g_old_free_purgeable;
 realloc_type g_old_realloc_purgeable;
 memalign_type g_old_memalign_purgeable;
 
 void* oom_killer_malloc(struct _malloc_zone_t* zone,
                         size_t size) {
   void* result = g_old_malloc(zone, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void* oom_killer_calloc(struct _malloc_zone_t* zone,
                         size_t num_items,
                         size_t size) {
   void* result = g_old_calloc(zone, num_items, size);
   if (!result && num_items && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(num_items * size);
   return result;
 }
 
 void* oom_killer_valloc(struct _malloc_zone_t* zone,
                         size_t size) {
   void* result = g_old_valloc(zone, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void oom_killer_free(struct _malloc_zone_t* zone,
                      void* ptr) {
   g_old_free(zone, ptr);
 }
 
 void* oom_killer_realloc(struct _malloc_zone_t* zone,
                          void* ptr,
                          size_t size) {
   void* result = g_old_realloc(zone, ptr, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void* oom_killer_memalign(struct _malloc_zone_t* zone,
                           size_t alignment,
                           size_t size) {
   void* result = g_old_memalign(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*) &&
       (alignment & (alignment - 1)) == 0) {
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   }
   return result;
 }
 
 void* oom_killer_malloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
   void* result = g_old_malloc_purgeable(zone, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void* oom_killer_calloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t num_items,
                                   size_t size) {
   void* result = g_old_calloc_purgeable(zone, num_items, size);
   if (!result && num_items && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(num_items * size);
   return result;
 }
 
 void* oom_killer_valloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
   void* result = g_old_valloc_purgeable(zone, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void oom_killer_free_purgeable(struct _malloc_zone_t* zone,
                                void* ptr) {
   g_old_free_purgeable(zone, ptr);
 }
 
 void* oom_killer_realloc_purgeable(struct _malloc_zone_t* zone,
                                    void* ptr,
                                    size_t size) {
   void* result = g_old_realloc_purgeable(zone, ptr, size);
   if (!result && size)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   return result;
 }
 
 void* oom_killer_memalign_purgeable(struct _malloc_zone_t* zone,
                                     size_t alignment,
                                     size_t size) {
   void* result = g_old_memalign_purgeable(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*)
       && (alignment & (alignment - 1)) == 0) {
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(size);
   }
   return result;
 }
 
 #endif  // !defined(ADDRESS_SANITIZER)
 
 // === C++ operator new ===
 
 void oom_killer_new() {
-  debug::BreakDebugger();
+  TerminateBecauseOutOfMemory(0);
 }
 
 #if !defined(ADDRESS_SANITIZER)
 
 // === Core Foundation CFAllocators ===
 
 bool CanGetContextForCFAllocator() {
   return !base::mac::IsOSLaterThanYosemite_DontCallThis();
 }
 
@@ skipping 18 matching lines @@
 
 CFAllocatorAllocateCallBack g_old_cfallocator_system_default;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc_zone;
 
 void* oom_killer_cfallocator_system_default(CFIndex alloc_size,
                                             CFOptionFlags hint,
                                             void* info) {
   void* result = g_old_cfallocator_system_default(alloc_size, hint, info);
   if (!result)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(alloc_size);
   return result;
 }
 
 void* oom_killer_cfallocator_malloc(CFIndex alloc_size,
                                     CFOptionFlags hint,
                                     void* info) {
   void* result = g_old_cfallocator_malloc(alloc_size, hint, info);
   if (!result)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(alloc_size);
   return result;
 }
 
 void* oom_killer_cfallocator_malloc_zone(CFIndex alloc_size,
                                          CFOptionFlags hint,
                                          void* info) {
   void* result = g_old_cfallocator_malloc_zone(alloc_size, hint, info);
   if (!result)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(alloc_size);
   return result;
 }
 
 #endif  // !defined(ADDRESS_SANITIZER)
 
 // === Cocoa NSObject allocation ===
 
 typedef id (*allocWithZone_t)(id, SEL, NSZone*);
 allocWithZone_t g_old_allocWithZone;
 
 id oom_killer_allocWithZone(id self, SEL _cmd, NSZone* zone)
 {
   id result = g_old_allocWithZone(self, _cmd, zone);
   if (!result)
-    debug::BreakDebugger();
+    TerminateBecauseOutOfMemory(0);
   return result;
 }
 
 }  // namespace
 
 bool UncheckedMalloc(size_t size, void** result) {
 #if defined(ADDRESS_SANITIZER)
   *result = malloc(size);
 #else
   if (g_old_malloc) {
@@ skipping 228 matching lines @@
                                             @selector(allocWithZone:));
   g_old_allocWithZone = reinterpret_cast<allocWithZone_t>(
       method_getImplementation(orig_method));
   CHECK(g_old_allocWithZone)
       << "Failed to get allocWithZone allocation function.";
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 }  // namespace base