Change call_new_handler to be non extern C; not called outside this code and it's causing issues wi…

base/allocator/allocator_shim.cc

 // 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.
 
 #include "base/allocator/allocator_shim.h"
 
 #include <config.h>
 #include "base/allocator/allocator_extension_thunks.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/sysinfo.h"
@@ skipping 55 matching lines @@
 // Forward declarations from jemalloc.
 extern "C" {
 void* je_malloc(size_t s);
 void* je_realloc(void* p, size_t s);
 void je_free(void* s);
 size_t je_msize(void* p);
 bool je_malloc_init_hard();
 void* je_memalign(size_t a, size_t s);
 }
 
-extern "C" {
-
 // Call the new handler, if one has been set.
 // Returns true on successfully calling the handler, false otherwise.
 inline bool call_new_handler(bool nothrow) {
   // Get the current new handler.  NB: this function is not
   // thread-safe.  We make a feeble stab at making it so here, but
   // this lock only protects against tcmalloc interfering with
   // itself, not with other libraries calling set_new_handler.
   std::new_handler nh;
   {
     SpinLockHolder h(&set_new_handler_lock);
     nh = std::set_new_handler(0);
     (void) std::set_new_handler(nh);
   }
-#if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS)
+#if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
+    (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.
   (*nh)();
   return false;  // break out of the retry loop.
 #else
   // If no new_handler is established, the allocation failed.
   if (!nh) {
     if (nothrow)
-      return 0;
+      return false;
     throw std::bad_alloc();
   }
   // Otherwise, try the new_handler.  If it returns, retry the
   // allocation.  If it throws std::bad_alloc, fail the allocation.
   // if it throws something else, don't interfere.
   try {
     (*nh)();
   } catch (const std::bad_alloc&) {
     if (!nothrow)
       throw;
     return true;
   }
 #endif  // (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS)
+  return false;
 }
 
+extern "C" {
 void* malloc(size_t size) __THROW {
   void* ptr;
   for (;;) {
 #ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
     switch (allocator) {
       case JEMALLOC:
         ptr = je_malloc(size);
         break;
       case WINHEAP:
       case WINLFH:
@@ skipping 308 matching lines @@
 void TCMallocDoFreeForTest(void* ptr) {
   do_free(ptr);
 }
 
 size_t ExcludeSpaceForMarkForTest(size_t size) {
   return ExcludeSpaceForMark(size);
 }
 
 }  // namespace allocator.
 }  // namespace base.