base: Remove the string logging from CHECK().

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>
 #import <Foundation/Foundation.h>
 #include <errno.h>
 #include <mach/mach.h>
@@ skipping 346 matching lines @@
   // MALLOC_ABSOLUTE_MAX_SIZE (currently SIZE_T_MAX - (2 * PAGE_SIZE)) will
   // still fail with a NULL rather than dying (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c for details).
   // Unfortunately, it's the best we can do. Also note that this does not affect
   // allocations from non-default zones.
 
 #if !defined(ADDRESS_SANITIZER)
   // Don't do anything special on OOM for the malloc zones replaced by
   // AddressSanitizer, as modifying or protecting them may not work correctly.
 
+  // Old allocators unexpectedly non-null
   CHECK(!g_old_malloc && !g_old_calloc && !g_old_valloc && !g_old_realloc &&
-        !g_old_memalign) << "Old allocators unexpectedly non-null";
+        !g_old_memalign);
 
+  // Old allocators unexpectedly non-null
   CHECK(!g_old_malloc_purgeable && !g_old_calloc_purgeable &&
         !g_old_valloc_purgeable && !g_old_realloc_purgeable &&
-        !g_old_memalign_purgeable) << "Old allocators unexpectedly non-null";
+        !g_old_memalign_purgeable);
 
   ChromeMallocZone* default_zone =
       reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
   ChromeMallocZone* purgeable_zone =
       reinterpret_cast<ChromeMallocZone*>(malloc_default_purgeable_zone());
 
   mach_vm_address_t default_reprotection_start = 0;
   mach_vm_size_t default_reprotection_length = 0;
   vm_prot_t default_reprotection_value = VM_PROT_NONE;
   DeprotectMallocZone(default_zone,
@@ skipping 11 matching lines @@
                         &purgeable_reprotection_value);
   }
 
   // Default zone
 
   g_old_malloc = default_zone->malloc;
   g_old_calloc = default_zone->calloc;
   g_old_valloc = default_zone->valloc;
   g_old_free = default_zone->free;
   g_old_realloc = default_zone->realloc;
+  // Failed to get system allocation functions.
   CHECK(g_old_malloc && g_old_calloc && g_old_valloc && g_old_free &&
-        g_old_realloc)
-      << "Failed to get system allocation functions.";
+        g_old_realloc);
 
   default_zone->malloc = oom_killer_malloc;
   default_zone->calloc = oom_killer_calloc;
   default_zone->valloc = oom_killer_valloc;
   default_zone->free = oom_killer_free;
   default_zone->realloc = oom_killer_realloc;
 
   if (default_zone->version >= 5) {
     g_old_memalign = default_zone->memalign;
     if (g_old_memalign)
       default_zone->memalign = oom_killer_memalign;
   }
 
   // Purgeable zone (if it exists)
 
   if (purgeable_zone) {
     g_old_malloc_purgeable = purgeable_zone->malloc;
     g_old_calloc_purgeable = purgeable_zone->calloc;
     g_old_valloc_purgeable = purgeable_zone->valloc;
     g_old_free_purgeable = purgeable_zone->free;
     g_old_realloc_purgeable = purgeable_zone->realloc;
+    // Failed to get system allocation functions.
     CHECK(g_old_malloc_purgeable && g_old_calloc_purgeable &&
           g_old_valloc_purgeable && g_old_free_purgeable &&
-          g_old_realloc_purgeable)
-        << "Failed to get system allocation functions.";
+          g_old_realloc_purgeable);
 
     purgeable_zone->malloc = oom_killer_malloc_purgeable;
     purgeable_zone->calloc = oom_killer_calloc_purgeable;
     purgeable_zone->valloc = oom_killer_valloc_purgeable;
     purgeable_zone->free = oom_killer_free_purgeable;
     purgeable_zone->realloc = oom_killer_realloc_purgeable;
 
     if (purgeable_zone->version >= 5) {
       g_old_memalign_purgeable = purgeable_zone->memalign;
       if (g_old_memalign_purgeable)
@@ skipping 46 matching lines @@
   // that our imperfect handling of malloc cannot.
 
   std::set_new_handler(oom_killer_new);
 
 #ifndef ADDRESS_SANITIZER
   // === Core Foundation CFAllocators ===
 
   // This will not catch allocation done by custom allocators, but will catch
   // all allocation done by system-provided ones.
 
+  // Old allocators unexpectedly non-null
   CHECK(!g_old_cfallocator_system_default && !g_old_cfallocator_malloc &&
-        !g_old_cfallocator_malloc_zone)
-      << "Old allocators unexpectedly non-null";
+        !g_old_cfallocator_malloc_zone);
 
   bool cf_allocator_internals_known = CanGetContextForCFAllocator();
 
   if (cf_allocator_internals_known) {
     CFAllocatorContext* context =
         ContextForCFAllocator(kCFAllocatorSystemDefault);
-    CHECK(context) << "Failed to get context for kCFAllocatorSystemDefault.";
+    // Failed to get context for kCFAllocatorSystemDefault.
+    CHECK(context);
     g_old_cfallocator_system_default = context->allocate;
-    CHECK(g_old_cfallocator_system_default)
-        << "Failed to get kCFAllocatorSystemDefault allocation function.";
+    // Failed to get kCFAllocatorSystemDefault allocation function.
+    CHECK(g_old_cfallocator_system_default);
     context->allocate = oom_killer_cfallocator_system_default;
 
     context = ContextForCFAllocator(kCFAllocatorMalloc);
-    CHECK(context) << "Failed to get context for kCFAllocatorMalloc.";
+    // Failed to get context for kCFAllocatorMalloc.
+    CHECK(context);
     g_old_cfallocator_malloc = context->allocate;
-    CHECK(g_old_cfallocator_malloc)
-        << "Failed to get kCFAllocatorMalloc allocation function.";
+    // Failed to get kCFAllocatorMalloc allocation function.
+    CHECK(g_old_cfallocator_malloc);
     context->allocate = oom_killer_cfallocator_malloc;
 
     context = ContextForCFAllocator(kCFAllocatorMallocZone);
-    CHECK(context) << "Failed to get context for kCFAllocatorMallocZone.";
+    // Failed to get context for kCFAllocatorMallocZone.
+    CHECK(context);
     g_old_cfallocator_malloc_zone = context->allocate;
-    CHECK(g_old_cfallocator_malloc_zone)
-        << "Failed to get kCFAllocatorMallocZone allocation function.";
+    // Failed to get kCFAllocatorMallocZone allocation function.
+    CHECK(g_old_cfallocator_malloc_zone);
     context->allocate = oom_killer_cfallocator_malloc_zone;
   } else {
     DLOG(WARNING) << "Internals of CFAllocator not known; out-of-memory "
                      "failures via CFAllocator will not result in termination. "
                      "http://crbug.com/45650";
   }
 #endif
 
   // === Cocoa NSObject allocation ===
 
   // Note that both +[NSObject new] and +[NSObject alloc] call through to
   // +[NSObject allocWithZone:].
 
-  CHECK(!g_old_allocWithZone)
-      << "Old allocator unexpectedly non-null";
+  // Old allocator unexpectedly non-null
+  CHECK(!g_old_allocWithZone);
 
   Class nsobject_class = [NSObject class];
   Method orig_method = class_getClassMethod(nsobject_class,
                                             @selector(allocWithZone:));
   g_old_allocWithZone = reinterpret_cast<allocWithZone_t>(
       method_getImplementation(orig_method));
-  CHECK(g_old_allocWithZone)
-      << "Failed to get allocWithZone allocation function.";
+  // Failed to get allocWithZone allocation function.
+  CHECK(g_old_allocWithZone);
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 }  // namespace base