Replace CHECK(false) in base/

In most cases NOTREACHED() is now a better option. Also performs
dead-code removal.

Bug: 40122554, 40580068
Change-Id: I5d0ef0b0c05a913a040905f7bebbbbf22985fef8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6011172
Reviewed-by: Lei Zhang <[email protected]>
Commit-Queue: Peter Boström <[email protected]>
Code-Coverage: [email protected] <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1382693}


CrOS-Libchrome-Original-Commit: 541196559fa83bb1abe11cedbca23d410a8b00d9

Author: pbos

base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/debug/alias.h

@@ -35,7 +35,7 @@ namespace partition_alloc::internal::base::debug {
 //   strncpy(name_copy, p->name, sizeof(name_copy)-1);
 //   name_copy[sizeof(name_copy)-1] = '\0';;
 //   base::debug::alias(name_copy);
-//   CHECK(false);
+//   NOTREACHED();
 //
 // Case #2: Prevent a tail call into a function. This is useful to make sure the
 // function containing the call to base::debug::Alias() will be present in the

base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/numerics/safe_conversions_impl.h

@@ -89,7 +89,7 @@ constexpr bool kEnableAsmCode = true;
 constexpr bool kEnableAsmCode = false;
 #endif
 
-// Forces a crash, like a CHECK(false). Used for numeric boundary errors.
+// Forces a crash, like a NOTREACHED(). Used for numeric boundary errors.
 // Also used in a constexpr template to trigger a compilation failure on
 // an error condition.
 struct CheckOnFailure {

base/barrier_callback.h

@@ -16,6 +16,7 @@
 #include "base/functional/bind.h"
 #include "base/functional/callback.h"
 #include "base/functional/callback_helpers.h"
+#include "base/notreached.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_annotations.h"
 
@@ -55,7 +56,7 @@ class BarrierCallbackInfo {
 
 template <typename T>
 void ShouldNeverRun(T t) {
-  CHECK(false);
+  NOTREACHED();
 }
 
 }  // namespace internal

base/barrier_callback_unittest.cc

@@ -29,7 +29,7 @@ TEST(BarrierCallbackTest, ErrorToCallCallbackWithZeroCallbacks) {
       base::BarrierCallback<int>(0, base::BindOnce([](std::vector<int>) {}));
   EXPECT_FALSE(barrier_callback.is_null());
 
-  EXPECT_CHECK_DEATH(barrier_callback.Run(3));
+  EXPECT_NOTREACHED_DEATH(barrier_callback.Run(3));
 }
 
 TEST(BarrierCallbackTest, RunAfterNumCallbacks) {

base/barrier_closure.cc

@@ -9,6 +9,7 @@
 #include "base/atomic_ref_count.h"
 #include "base/functional/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/notreached.h"
 #include "base/numerics/safe_conversions.h"
 
 namespace base {
@@ -38,7 +39,7 @@ void BarrierInfo::Run() {
 }
 
 void ShouldNeverRun() {
-  CHECK(false);
+  NOTREACHED();
 }
 
 }  // namespace

base/barrier_closure_unittest.cc

@@ -26,7 +26,7 @@ TEST(BarrierClosureTest, ChecksIfCalledForZeroClosures) {
       base::BarrierClosure(0, base::DoNothing());
   EXPECT_FALSE(barrier_closure.is_null());
 
-  EXPECT_CHECK_DEATH(barrier_closure.Run());
+  EXPECT_NOTREACHED_DEATH(barrier_closure.Run());
 }
 
 TEST(BarrierClosureTest, RunAfterNumClosures) {

base/debug/alias.h

@@ -33,7 +33,7 @@ namespace debug {
 //   int last_error = err_;
 //   base::debug::Alias(&last_error);
 //   DEBUG_ALIAS_FOR_CSTR(name_copy, p->name, 16);
-//   CHECK(false);
+//   NOTREACHED();
 //
 // Case #2: Prevent a tail call into a function. This is useful to make sure the
 // function containing the call to base::debug::Alias() will be present in the

base/debug/asan_invalid_access.cc

@@ -15,6 +15,7 @@
 
 #include "base/check.h"
 #include "base/debug/alias.h"
+#include "base/immediate_crash.h"
 #include "build/build_config.h"
 
 #if BUILDFLAG(IS_WIN)
@@ -47,8 +48,9 @@ NOINLINE void CorruptMemoryBlock(bool induce_crash) {
   LONG volatile dummy = InterlockedIncrementFn(array - 1);
   base::debug::Alias(const_cast<LONG*>(&dummy));
 
-  if (induce_crash)
-    CHECK(false);
+  if (induce_crash) {
+    base::ImmediateCrash();
+  }
   delete[] array;
 }
 #endif  // BUILDFLAG(IS_WIN) && defined(ADDRESS_SANITIZER)

base/logging.cc

@@ -638,11 +638,11 @@ namespace {
                                 const char* buf_start,
                                 const char* prefix_end,
                                 const char* buf_end) {
-  // This simulates a CHECK(false) at file:line instead of here. This is used
+  // This simulates a NOTREACHED() at file:line instead of here. This is used
   // instead of base::ImmediateCrash() to give better error messages locally
   // (printed stack for one).
   LogMessageFatal(file, line, LOGGING_FATAL).stream()
-      << "Check failed: false. " << prefix_end;
+      << "NOTREACHED hit. " << prefix_end;
 }
 
 }  // namespace

base/memory/aligned_memory.cc

@@ -6,6 +6,7 @@
 
 #include <bit>
 
+#include "base/check.h"
 #include "base/check_op.h"
 #include "base/logging.h"
 #include "build/build_config.h"
@@ -41,11 +42,9 @@ void* AlignedAlloc(size_t size, size_t alignment) {
   // Since aligned allocations may fail for non-memory related reasons, force a
   // crash if we encounter a failed allocation; maintaining consistent behavior
   // with a normal allocation failure in Chrome.
-  if (!ptr) {
-    DLOG(ERROR) << "If you crashed here, your aligned allocation is incorrect: "
-                << "size=" << size << ", alignment=" << alignment;
-    CHECK(false);
-  }
+  CHECK(ptr) << "If you crashed here, your aligned allocation is incorrect: "
+             << "size=" << size << ", alignment=" << alignment;
+
   // Sanity check alignment just to be safe.
   DCHECK(IsAligned(ptr, alignment));
   return ptr;