Replace remaining ASSERT with DCHECK/_EQ as appropriate

third_party/WebKit/Source/core/streams/ReadableStreamOperations.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/streams/ReadableStreamOperations.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/streams/UnderlyingSourceBase.h"
@@ skipping 26 matching lines @@
       v8::Number::New(script_state->GetIsolate(), high_water_mark)};
   return ScriptValue(
       script_state,
       V8ScriptRunner::CallExtraOrCrash(
           script_state, "createBuiltInCountQueuingStrategy", args));
 }
 
 ScriptValue ReadableStreamOperations::GetReader(ScriptState* script_state,
                                                 ScriptValue stream,
                                                 ExceptionState& es) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::TryCatch block(script_state->GetIsolate());
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   ScriptValue result(
       script_state,
       V8ScriptRunner::CallExtra(script_state,
                                 "AcquireReadableStreamDefaultReader", args));
   if (block.HasCaught())
     es.RethrowV8Exception(block.Exception());
   return result;
 }
 
 bool ReadableStreamOperations::IsReadableStream(ScriptState* script_state,
                                                 ScriptValue value) {
   DCHECK(!value.IsEmpty());
 
   if (!value.IsObject())
     return false;
 
   v8::Local<v8::Value> args[] = {value.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state, "IsReadableStream",
                                           args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsDisturbed(ScriptState* script_state,
                                            ScriptValue stream) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamDisturbed", args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsLocked(ScriptState* script_state,
                                         ScriptValue stream) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamLocked", args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsReadable(ScriptState* script_state,
                                           ScriptValue stream) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamReadable", args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsClosed(ScriptState* script_state,
                                         ScriptValue stream) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamClosed", args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsErrored(ScriptState* script_state,
                                          ScriptValue stream) {
-  ASSERT(IsReadableStream(script_state, stream));
+  DCHECK(IsReadableStream(script_state, stream));
 
   v8::Local<v8::Value> args[] = {stream.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamErrored", args)
       ->ToBoolean()
       ->Value();
 }
 
 bool ReadableStreamOperations::IsReadableStreamDefaultReader(
     ScriptState* script_state,
     ScriptValue value) {
   DCHECK(!value.IsEmpty());
 
   if (!value.IsObject())
     return false;
 
   v8::Local<v8::Value> args[] = {value.V8Value()};
   return V8ScriptRunner::CallExtraOrCrash(script_state,
                                           "IsReadableStreamDefaultReader", args)
       ->ToBoolean()
       ->Value();
 }
 
 ScriptPromise ReadableStreamOperations::DefaultReaderRead(
     ScriptState* script_state,
     ScriptValue reader) {
-  ASSERT(IsReadableStreamDefaultReader(script_state, reader));
+  DCHECK(IsReadableStreamDefaultReader(script_state, reader));
 
   v8::Local<v8::Value> args[] = {reader.V8Value()};
   return ScriptPromise::Cast(
       script_state, V8ScriptRunner::CallExtraOrCrash(
                         script_state, "ReadableStreamDefaultReaderRead", args));
 }
 
 void ReadableStreamOperations::Tee(ScriptState* script_state,
                                    ScriptValue stream,
                                    ScriptValue* new_stream1,
@@ skipping 15 matching lines @@
       branches->Get(script_state->GetContext(), 0).ToLocalChecked());
   *new_stream2 = ScriptValue(
       script_state,
       branches->Get(script_state->GetContext(), 1).ToLocalChecked());
 
   DCHECK(IsReadableStream(script_state, *new_stream1));
   DCHECK(IsReadableStream(script_state, *new_stream2));
 }
 
 }  // namespace blink