Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

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

 /*
  * Copyright (C) 2006, 2007, 2008, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 45 matching lines @@
       worker_global_scope_(nullptr) {
   if (IsMainThread())
     InstanceCounters::IncrementCounter(
         InstanceCounters::kJSEventListenerCounter);
   else
     worker_global_scope_ =
         ToWorkerGlobalScope(CurrentExecutionContext(isolate));
 }
 
 V8AbstractEventListener::~V8AbstractEventListener() {
-  ASSERT(listener_.IsEmpty());
+  DCHECK(listener_.IsEmpty());
   if (IsMainThread())
     InstanceCounters::DecrementCounter(
         InstanceCounters::kJSEventListenerCounter);
 }
 
 void V8AbstractEventListener::handleEvent(ExecutionContext* execution_context,
                                           Event* event) {
   if (!execution_context)
     return;
   // Don't reenter V8 if execution was terminated in this instance of V8.
   if (execution_context->IsJSExecutionForbidden())
     return;
 
   // A ScriptState used by the event listener needs to be calculated based on
   // the ExecutionContext that fired the the event listener and the world
   // that installed the event listener.
-  ASSERT(event);
+  DCHECK(event);
   v8::HandleScope handle_scope(ToIsolate(execution_context));
   v8::Local<v8::Context> v8_context = ToV8Context(execution_context, World());
   if (v8_context.IsEmpty())
     return;
   ScriptState* script_state = ScriptState::From(v8_context);
   if (!script_state->ContextIsValid())
     return;
   HandleEvent(script_state, event);
 }
 
 void V8AbstractEventListener::HandleEvent(ScriptState* script_state,
                                           Event* event) {
   ScriptState::Scope scope(script_state);
 
   // Get the V8 wrapper for the event object.
   v8::Local<v8::Value> js_event =
       ToV8(event, script_state->GetContext()->Global(), GetIsolate());
   if (js_event.IsEmpty())
     return;
   InvokeEventHandler(script_state, event,
                      v8::Local<v8::Value>::New(GetIsolate(), js_event));
 }
 
 void V8AbstractEventListener::SetListenerObject(
     v8::Local<v8::Object> listener) {
-  ASSERT(listener_.IsEmpty());
+  DCHECK(listener_.IsEmpty());
   // Balanced in wrapperCleared xor clearListenerObject.
   if (worker_global_scope_) {
     worker_global_scope_->RegisterEventListener(this);
   } else {
     keep_alive_ = this;
   }
   listener_.Set(GetIsolate(), listener, this, &WrapperCleared);
 }
 
 void V8AbstractEventListener::InvokeEventHandler(
@@ skipping 111 matching lines @@
 DEFINE_TRACE(V8AbstractEventListener) {
   visitor->Trace(worker_global_scope_);
   EventListener::Trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(V8AbstractEventListener) {
   visitor->TraceWrappers(listener_.Cast<v8::Value>());
 }
 
 }  // namespace blink