Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 73 matching lines @@
         V8Window::findInstanceInPrototypeChain(host, isolate);
     if (window_wrapper.IsEmpty())
       return 0;
     return V8Window::toImpl(window_wrapper)->GetFrame();
   }
 
   if (V8Location::wrapperTypeInfo.Equals(type))
     return V8Location::toImpl(host)->GetFrame();
 
   // This function can handle only those types listed above.
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return 0;
 }
 
 static void ReportFatalErrorInMainThread(const char* location,
                                          const char* message) {
   int memory_usage_mb = Platform::Current()->ActualMemoryUsageMB();
   DVLOG(1) << "V8 error: " << message << " (" << location
            << ").  Current memory usage: " << memory_usage_mb << " MB";
   CRASH();
 }
@@ skipping 45 matching lines @@
 
 // NOTE: when editing this, please also edit the error messages we throw when
 // the size is exceeded (see uses of the constant), which use the human-friendly
 // "4KB" text.
 const size_t kWasmWireBytesLimit = 1 << 12;
 
 }  // namespace
 
 void V8Initializer::MessageHandlerInMainThread(v8::Local<v8::Message> message,
                                                v8::Local<v8::Value> data) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 
   if (isolate->GetEnteredContext().IsEmpty())
     return;
 
   // If called during context initialization, there will be no entered context.
   ScriptState* script_state = ScriptState::Current(isolate);
   if (!script_state->ContextIsValid())
     return;
 
@@ skipping 24 matching lines @@
     event->SetUnsanitizedMessage("Uncaught " + message_for_console);
 
   V8ErrorHandler::StoreExceptionOnErrorEventWrapper(
       script_state, event, data, script_state->GetContext()->Global());
   context->DispatchErrorEvent(event, access_control_status);
 }
 
 namespace {
 
 static RejectedPromises& RejectedPromisesOnMainThread() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_LOCAL(RefPtr<RejectedPromises>, rejected_promises,
                       (RejectedPromises::Create()));
   return *rejected_promises;
 }
 
 }  // namespace
 
 void V8Initializer::ReportRejectedPromisesOnMainThread() {
   RejectedPromisesOnMainThread().ProcessQueue();
 }
 
 static void PromiseRejectHandler(v8::PromiseRejectMessage data,
                                  RejectedPromises& rejected_promises,
                                  ScriptState* script_state) {
   if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
     rejected_promises.HandlerAdded(data);
     return;
   }
 
-  ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
+  DCHECK_EQ(data.GetEvent(), v8::kPromiseRejectWithNoHandler);
 
   v8::Local<v8::Promise> promise = data.GetPromise();
   v8::Isolate* isolate = promise->GetIsolate();
   ExecutionContext* context = ExecutionContext::From(script_state);
 
   v8::Local<v8::Value> exception = data.GetValue();
   if (V8DOMWrapper::IsWrapper(isolate, exception)) {
     // Try to get the stack & location from a wrapped exception object (e.g.
     // DOMException).
-    ASSERT(exception->IsObject());
+    DCHECK(exception->IsObject());
     auto private_error = V8PrivateProperty::GetDOMExceptionError(isolate);
     v8::Local<v8::Value> error =
         private_error.GetOrUndefined(exception.As<v8::Object>());
     if (!error->IsUndefined())
       exception = error;
   }
 
   String error_message;
   AccessControlStatus cors_status = kNotSharableCrossOrigin;
   std::unique_ptr<SourceLocation> location;
@@ skipping 14 matching lines @@
   String message_for_console =
       ExtractMessageForConsole(isolate, data.GetValue());
   if (!message_for_console.IsEmpty())
     error_message = "Uncaught " + message_for_console;
 
   rejected_promises.RejectedWithNoHandler(script_state, data, error_message,
                                           std::move(location), cors_status);
 }
 
 static void PromiseRejectHandlerInMainThread(v8::PromiseRejectMessage data) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
 
   v8::Local<v8::Promise> promise = data.GetPromise();
 
   v8::Isolate* isolate = promise->GetIsolate();
 
   // TODO(ikilpatrick): Remove this check, extensions tests that use
   // extensions::ModuleSystemTest incorrectly don't have a valid script state.
   LocalDOMWindow* window = CurrentDOMWindow(isolate);
   if (!window || !window->IsCurrentlyDisplayedInFrame())
     return;
@@ skipping 12 matching lines @@
   // Bail out if called during context initialization.
   v8::Isolate* isolate = promise->GetIsolate();
   ScriptState* script_state = ScriptState::Current(isolate);
   if (!script_state->ContextIsValid())
     return;
 
   ExecutionContext* execution_context = ExecutionContext::From(script_state);
   if (!execution_context)
     return;
 
-  ASSERT(execution_context->IsWorkerGlobalScope());
+  DCHECK(execution_context->IsWorkerGlobalScope());
   WorkerOrWorkletScriptController* script_controller =
       ToWorkerGlobalScope(execution_context)->ScriptController();
-  ASSERT(script_controller);
+  DCHECK(script_controller);
 
   PromiseRejectHandler(data, *script_controller->GetRejectedPromises(),
                        script_state);
 }
 
 static void FailedAccessCheckCallbackInMainThread(v8::Local<v8::Object> host,
                                                   v8::AccessType type,
                                                   v8::Local<v8::Value> data) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   Frame* target = FindFrame(isolate, host, data);
@@ skipping 123 matching lines @@
     process_total += diff;
     DCHECK_GE(process_total, 0)
         << "total amount = " << process_total << ", diff = " << diff;
   }
 #endif
 
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(diff);
 }
 
 void V8Initializer::InitializeMainThread() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
 
   WTF::ArrayBufferContents::Initialize(AdjustAmountOfExternalAllocatedMemory);
 
   DEFINE_STATIC_LOCAL(ArrayBufferAllocator, array_buffer_allocator, ());
   auto v8_extras_mode = RuntimeEnabledFeatures::experimentalV8ExtrasEnabled()
                             ? gin::IsolateHolder::kStableAndExperimentalV8Extras
                             : gin::IsolateHolder::kStableV8Extras;
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  v8_extras_mode, &array_buffer_allocator);
 
@@ skipping 26 matching lines @@
   }
 
   isolate->SetPromiseRejectCallback(PromiseRejectHandlerInMainThread);
 
   if (v8::HeapProfiler* profiler = isolate->GetHeapProfiler()) {
     profiler->SetWrapperClassInfoProvider(
         WrapperTypeInfo::kNodeClassId, &RetainedDOMInfo::CreateRetainedDOMInfo);
     profiler->SetGetRetainerInfosCallback(&V8GCController::GetRetainerInfos);
   }
 
-  ASSERT(ThreadState::MainThreadState());
+  DCHECK(ThreadState::MainThreadState());
   ThreadState::MainThreadState()->RegisterTraceDOMWrappers(
       isolate, V8GCController::TraceDOMWrappers,
       ScriptWrappableVisitor::InvalidateDeadObjectsInMarkingDeque,
       ScriptWrappableVisitor::PerformCleanup);
 
   V8PerIsolateData::From(isolate)->SetThreadDebugger(
       WTF::MakeUnique<MainThreadDebugger>(isolate));
 
   BindingSecurity::InitWrapperCreationSecurityCheck();
 }
@@ skipping 75 matching lines @@
           v8::Isolate::kMessageLog);
   isolate->SetFatalErrorHandler(ReportFatalErrorInWorker);
 
   uint32_t here;
   isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here) -
                          kWorkerMaxStackSize);
   isolate->SetPromiseRejectCallback(PromiseRejectHandlerInWorker);
 }
 
 }  // namespace blink