Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.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 27 matching lines @@
 #include "platform/wtf/LeakAnnotations.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "v8/include/v8-debug.h"
 
 namespace blink {
 
 static V8PerIsolateData* g_main_thread_per_isolate_data = 0;
 
 static void BeforeCallEnteredCallback(v8::Isolate* isolate) {
-  RELEASE_ASSERT(!ScriptForbiddenScope::IsScriptForbidden());
+  CHECK(!ScriptForbiddenScope::IsScriptForbidden());
 }
 
 static void MicrotasksCompletedCallback(v8::Isolate* isolate) {
   V8PerIsolateData::From(isolate)->RunEndOfScopeTasks();
 }
 
 V8PerIsolateData::V8PerIsolateData(WebTaskRunner* task_runner)
     : isolate_holder_(
           task_runner ? task_runner->ToSingleThreadTaskRunner() : nullptr,
           gin::IsolateHolder::kSingleThread,
           IsMainThread() ? gin::IsolateHolder::kDisallowAtomicsWait
                          : gin::IsolateHolder::kAllowAtomicsWait),
       string_cache_(WTF::WrapUnique(new StringCache(GetIsolate()))),
       private_property_(V8PrivateProperty::Create()),
       constructor_mode_(ConstructorMode::kCreateNewObject),
       use_counter_disabled_(false),
       is_handling_recursion_level_error_(false),
       is_reporting_exception_(false) {
   // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
   GetIsolate()->Enter();
   GetIsolate()->AddBeforeCallEnteredCallback(&BeforeCallEnteredCallback);
   GetIsolate()->AddMicrotasksCompletedCallback(&MicrotasksCompletedCallback);
   if (IsMainThread())
     g_main_thread_per_isolate_data = this;
 }
 
 V8PerIsolateData::~V8PerIsolateData() {}
 
 v8::Isolate* V8PerIsolateData::MainThreadIsolate() {
-  ASSERT(g_main_thread_per_isolate_data);
+  DCHECK(g_main_thread_per_isolate_data);
   return g_main_thread_per_isolate_data->GetIsolate();
 }
 
 v8::Isolate* V8PerIsolateData::Initialize(WebTaskRunner* task_runner) {
   V8PerIsolateData* data = new V8PerIsolateData(task_runner);
   v8::Isolate* isolate = data->GetIsolate();
   isolate->SetData(gin::kEmbedderBlink, data);
   return isolate;
 }
 
@@ skipping 183 matching lines @@
 
 void V8PerIsolateData::AddEndOfScopeTask(std::unique_ptr<EndOfScopeTask> task) {
   end_of_scope_tasks_.push_back(std::move(task));
 }
 
 void V8PerIsolateData::RunEndOfScopeTasks() {
   Vector<std::unique_ptr<EndOfScopeTask>> tasks;
   tasks.Swap(end_of_scope_tasks_);
   for (const auto& task : tasks)
     task->Run();
-  ASSERT(end_of_scope_tasks_.IsEmpty());
+  DCHECK(end_of_scope_tasks_.IsEmpty());
 }
 
 void V8PerIsolateData::ClearEndOfScopeTasks() {
   end_of_scope_tasks_.Clear();
 }
 
 void V8PerIsolateData::SetThreadDebugger(
     std::unique_ptr<V8PerIsolateData::Data> thread_debugger) {
-  ASSERT(!thread_debugger_);
+  DCHECK(!thread_debugger_);
   thread_debugger_ = std::move(thread_debugger);
 }
 
 V8PerIsolateData::Data* V8PerIsolateData::ThreadDebugger() {
   return thread_debugger_.get();
 }
 
 void V8PerIsolateData::AddActiveScriptWrappable(
     ActiveScriptWrappableBase* wrappable) {
   if (!active_script_wrappables_)
     active_script_wrappables_ = new ActiveScriptWrappableSet();
 
   active_script_wrappables_->insert(wrappable);
 }
 
 void V8PerIsolateData::TemporaryScriptWrappableVisitorScope::
     SwapWithV8PerIsolateDataVisitor(
         std::unique_ptr<ScriptWrappableVisitor>& visitor) {
   ScriptWrappableVisitor* current = CurrentVisitor();
   if (current)
     current->PerformCleanup();
 
   V8PerIsolateData::From(isolate_)->script_wrappable_visitor_.swap(
       saved_visitor_);
   isolate_->SetEmbedderHeapTracer(CurrentVisitor());
 }
 
 }  // namespace blink