Add sk_calloc and sk_calloc_throw to SkMemory_new_handler.cpp.

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 90 matching lines @@
   }
 
  private:
   ThreadLocalBoolean* scoped_tlb_;
   bool original_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadLocalBooleanAutoReset);
 };
 
 base::LazyInstance<ThreadLocalBoolean>::Leaky
-    g_unchecked_malloc = LAZY_INSTANCE_INITIALIZER;
+    g_unchecked_alloc = LAZY_INSTANCE_INITIALIZER;
 
 // NOTE(shess): This is called when the malloc library noticed that the heap
 // is fubar.  Avoid calls which will re-enter the malloc library.
 void CrMallocErrorBreak() {
   g_original_malloc_error_break();
 
   // Out of memory is certainly not heap corruption, and not necessarily
   // something for which the process should be terminated. Leave that decision
   // to the OOM killer.  The EBADF case comes up because the malloc library
   // attempts to log to ASL (syslog) before calling this code, which fails
   // accessing a Unix-domain socket because of sandboxing.
-  if (errno == ENOMEM || (errno == EBADF && g_unchecked_malloc.Get().Get()))
+  if (errno == ENOMEM || (errno == EBADF && g_unchecked_alloc.Get().Get()))
     return;
 
   // A unit test checks this error message, so it needs to be in release builds.
   char buf[1024] =
       "Terminating process due to a potential for future heap corruption: "
       "errno=";
   char errnobuf[] = {
     '0' + ((errno / 100) % 10),
     '0' + ((errno / 10) % 10),
     '0' + (errno % 10),
@@ skipping 350 matching lines @@
     debug::BreakDebugger();
   return result;
 }
 
 }  // namespace
 
 void* UncheckedMalloc(size_t size) {
   if (g_old_malloc) {
 #if ARCH_CPU_32_BITS
     ScopedClearErrno clear_errno;
-    ThreadLocalBooleanAutoReset flag(g_unchecked_malloc.Pointer(), true);
+    ThreadLocalBooleanAutoReset flag(g_unchecked_alloc.Pointer(), true);
 #endif  // ARCH_CPU_32_BITS
     return g_old_malloc(malloc_default_zone(), size);
   }
   return malloc(size);
 }
 
+void* UncheckedCalloc(size_t num_items, size_t size) {
+  if (g_old_calloc) {
+#if ARCH_CPU_32_BITS
+    ScopedClearErrno clear_errno;
+    ThreadLocalBooleanAutoReset flag(g_unchecked_alloc.Pointer(), true);
+#endif  // ARCH_CPU_32_BITS
+    return g_old_calloc(malloc_default_zone(), num_items, size);
+  }
+  return calloc(num_items, size);
+}
+
 void EnableTerminationOnOutOfMemory() {
   if (g_oom_killer_enabled)
     return;
 
   g_oom_killer_enabled = true;
 
   // === C malloc/calloc/valloc/realloc/posix_memalign ===
 
   // This approach is not perfect, as requests for amounts of memory larger than
   // MALLOC_ABSOLUTE_MAX_SIZE (currently SIZE_T_MAX - (2 * PAGE_SIZE)) will
@@ skipping 184 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