Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

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

 /*
  * Copyright (C) 2013 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 86 matching lines @@
       return ScriptValue();
     }
 
     const ResolveType resolve_type_;
     const size_t index_;
     Member<PromiseAllHandler> handler_;
   };
 
   PromiseAllHandler(ScriptState* script_state, Vector<ScriptPromise> promises)
       : number_of_pending_promises_(promises.size()), resolver_(script_state) {
-    ASSERT(!promises.IsEmpty());
+    DCHECK(!promises.IsEmpty());
     values_.Resize(promises.size());
     for (size_t i = 0; i < promises.size(); ++i)
       promises[i].Then(CreateFulfillFunction(script_state, i),
                        CreateRejectFunction(script_state));
   }
 
   v8::Local<v8::Function> CreateFulfillFunction(ScriptState* script_state,
                                                 size_t index) {
     return AdapterFunction::Create(script_state, AdapterFunction::kFulfilled,
                                    index, this);
   }
 
   v8::Local<v8::Function> CreateRejectFunction(ScriptState* script_state) {
     return AdapterFunction::Create(script_state, AdapterFunction::kRejected, 0,
                                    this);
   }
 
   void OnFulfilled(size_t index, const ScriptValue& value) {
     if (is_settled_)
       return;
 
-    ASSERT(index < values_.size());
+    DCHECK_LT(index, values_.size());
     values_[index] = value;
     if (--number_of_pending_promises_ > 0)
       return;
 
     v8::Local<v8::Array> values =
         v8::Array::New(value.GetIsolate(), values_.size());
     for (size_t i = 0; i < values_.size(); ++i) {
       if (!V8CallBoolean(values->CreateDataProperty(value.GetContext(), i,
                                                     values_[i].V8Value())))
         return;
     }
 
     MarkPromiseSettled();
     resolver_.Resolve(values);
   }
 
   void OnRejected(const ScriptValue& value) {
     if (is_settled_)
       return;
     MarkPromiseSettled();
     resolver_.Reject(value.V8Value());
   }
 
   void MarkPromiseSettled() {
-    ASSERT(!is_settled_);
+    DCHECK(!is_settled_);
     is_settled_ = true;
     values_.Clear();
   }
 
   size_t number_of_pending_promises_;
   ScriptPromise::InternalResolver resolver_;
   bool is_settled_ = false;
 
   // This is cleared when owners of this handler, that is, given promises are
   // settled.
@@ skipping 70 matching lines @@
   DecreaseInstanceCount();
 }
 
 ScriptPromise ScriptPromise::Then(v8::Local<v8::Function> on_fulfilled,
                                   v8::Local<v8::Function> on_rejected) {
   if (promise_.IsEmpty())
     return ScriptPromise();
 
   v8::Local<v8::Object> promise = promise_.V8Value().As<v8::Object>();
 
-  ASSERT(promise->IsPromise());
+  DCHECK(promise->IsPromise());
   // Return this Promise if no handlers are given.
   // In fact it is not the exact bahavior of Promise.prototype.then
   // but that is not a problem in this case.
   v8::Local<v8::Promise> result_promise = promise.As<v8::Promise>();
   if (!on_fulfilled.IsEmpty()) {
     if (!result_promise->Then(script_state_->GetContext(), on_fulfilled)
              .ToLocal(&result_promise))
       return ScriptPromise();
   }
   if (!on_rejected.IsEmpty()) {
@@ skipping 38 matching lines @@
   if (value.IsEmpty())
     return ScriptPromise();
   InternalResolver resolver(script_state);
   ScriptPromise promise = resolver.Promise();
   resolver.Reject(value);
   return promise;
 }
 
 ScriptPromise ScriptPromise::RejectWithDOMException(ScriptState* script_state,
                                                     DOMException* exception) {
-  ASSERT(script_state->GetIsolate()->InContext());
+  DCHECK(script_state->GetIsolate()->InContext());
   return Reject(script_state,
                 ToV8(exception, script_state->GetContext()->Global(),
                      script_state->GetIsolate()));
 }
 
 v8::Local<v8::Promise> ScriptPromise::RejectRaw(ScriptState* script_state,
                                                 v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return v8::Local<v8::Promise>();
   v8::Local<v8::Promise::Resolver> resolver;
@@ skipping 12 matching lines @@
 
 void ScriptPromise::IncreaseInstanceCount() {
   InstanceCounters::IncrementCounter(InstanceCounters::kScriptPromiseCounter);
 }
 
 void ScriptPromise::DecreaseInstanceCount() {
   InstanceCounters::DecrementCounter(InstanceCounters::kScriptPromiseCounter);
 }
 
 }  // namespace blink