base: Remove the string logging from CHECK().

base/debug/thread_heap_usage_tracker.cc

 // Copyright 2016 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/debug/thread_heap_usage_tracker.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <new>
 #include <type_traits>
@@ skipping 213 matching lines @@
   DCHECK(g_thread_allocator_usage.initialized());
 
   ThreadHeapUsage* usage = GetOrCreateThreadUsage();
   DCHECK_NE(nullptr, usage);
   return *usage;
 }
 
 void ThreadHeapUsageTracker::EnableHeapTracking() {
   EnsureTLSInitialized();
 
-  CHECK_EQ(false, g_heap_tracking_enabled) << "No double-enabling.";
+  // No double-enabling.
+  CHECK_EQ(false, g_heap_tracking_enabled);
   g_heap_tracking_enabled = true;
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   base::allocator::InsertAllocatorDispatch(&allocator_dispatch);
 #else
-  CHECK(false) << "Can't enable heap tracking without the shim.";
+  // Can't enable heap tracking without the shim.
+  CHECK(false);
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 }
 
 bool ThreadHeapUsageTracker::IsHeapTrackingEnabled() {
   return g_heap_tracking_enabled;
 }
 
 void ThreadHeapUsageTracker::DisableHeapTrackingForTesting() {
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   base::allocator::RemoveAllocatorDispatchForTesting(&allocator_dispatch);
 #else
-  CHECK(false) << "Can't disable heap tracking without the shim.";
+  // Can't disable heap tracking without the shim.
+  CHECK(false);
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   DCHECK_EQ(true, g_heap_tracking_enabled) << "Heap tracking not enabled.";
   g_heap_tracking_enabled = false;
 }
 
 base::allocator::AllocatorDispatch*
 ThreadHeapUsageTracker::GetDispatchForTesting() {
   return &allocator_dispatch;
 }
 
 void ThreadHeapUsageTracker::EnsureTLSInitialized() {
   if (!g_thread_allocator_usage.initialized()) {
     g_thread_allocator_usage.Initialize([](void* allocator_usage) {
       // Delegate the freeing of the per-thread structure to the next-lower
       // heap shim. Otherwise this free will re-initialize the TLS on thread
       // exit.
       allocator_dispatch.next->free_function(allocator_dispatch.next,
                                              allocator_usage);
     });
   }
 }
 
 }  // namespace debug
 }  // namespace base