Streams: Convert state DCHECKs to CHECKs

For "cheap" checks of state in the streams implementation, use CHECKs
instead of DCHECKs. This will improve robustness against logic errors.

BUG=1045931

Change-Id: I01af9c21feca586c74e354faa8f919fbb7565c64
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2032471Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Commit-Queue: Adam Rice <ricea@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737234}

third_party/blink/renderer/core/streams/readable_stream.cc

@@ -1557,7 +1557,7 @@ void ReadableStream::Initialize(ReadableStream* stream) {
   // initialised correctly.
   // https://streams.spec.whatwg.org/#initialize-readable-stream
   // 1. Set stream.[[state]] to "readable".
-  DCHECK_EQ(stream->state_, kReadable);
+  CHECK_EQ(stream->state_, kReadable);
   // 2. Set stream.[[reader]] and stream.[[storedError]] to undefined.
   DCHECK(!stream->reader_);
   DCHECK(stream->stored_error_.IsEmpty());
@@ -1670,7 +1670,7 @@ StreamPromiseResolver* ReadableStream::AddReadRequest(ScriptState* script_state,
   DCHECK(stream->reader_);
 
   // 2. Assert: stream.[[state]] is "readable".
-  DCHECK_EQ(stream->state_, kReadable);
+  CHECK_EQ(stream->state_, kReadable);
 
   // 3. Let promise be a new promise.
   auto* promise = MakeGarbageCollected<StreamPromiseResolver>(script_state);
@@ -1735,7 +1735,7 @@ v8::Local<v8::Promise> ReadableStream::Cancel(ScriptState* script_state,
 void ReadableStream::Close(ScriptState* script_state, ReadableStream* stream) {
   // https://streams.spec.whatwg.org/#readable-stream-close
   // 1. Assert: stream.[[state]] is "readable".
-  DCHECK_EQ(stream->state_, kReadable);
+  CHECK_EQ(stream->state_, kReadable);
 
   // 2. Set stream.[[state]] to "closed".
   stream->state_ = kClosed;
@@ -1822,7 +1822,7 @@ void ReadableStream::Error(ScriptState* script_state,
                            v8::Local<v8::Value> e) {
   // https://streams.spec.whatwg.org/#readable-stream-error
   // 2. Assert: stream.[[state]] is "readable".
-  DCHECK_EQ(stream->state_, kReadable);
+  CHECK_EQ(stream->state_, kReadable);
   auto* isolate = script_state->GetIsolate();
 
   // 3. Set stream.[[state]] to "errored".

third_party/blink/renderer/core/streams/readable_stream_default_controller.cc

@@ -111,7 +111,7 @@ void ReadableStreamDefaultController::Close(
 
   // 2. Assert: ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)
   //    is true.
-  DCHECK(CanCloseOrEnqueue(controller));
+  CHECK(CanCloseOrEnqueue(controller));
 
   // 3. Set controller.[[closeRequested]] to true.
   controller->is_close_requested_ = true;
@@ -137,7 +137,7 @@ void ReadableStreamDefaultController::Enqueue(
 
   // 2. Assert: ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)
   //    is true.
-  DCHECK(CanCloseOrEnqueue(controller));
+  CHECK(CanCloseOrEnqueue(controller));
 
   // 3. If ! IsReadableStreamLocked(stream) is true and !
   //    ReadableStreamGetNumReadRequests(stream) > 0, perform !
@@ -260,7 +260,7 @@ const char* ReadableStreamDefaultController::EnqueueExceptionMessage(
   if (state == ReadableStream::kErrored) {
     return "Cannot enqueue a chunk into an errored readable stream";
   }
-  DCHECK(state == ReadableStream::kClosed);
+  CHECK(state == ReadableStream::kClosed);
   return "Cannot enqueue a chunk into a closed readable stream";
 }
 

third_party/blink/renderer/core/streams/transform_stream.cc

@@ -354,7 +354,7 @@ class TransformStream::DefaultSinkWriteAlgorithm final
           }
 
           // 4. Assert: state is "writable".
-          DCHECK(writable->IsWritable());
+          CHECK(writable->IsWritable());
 
           // 5. Return ! TransformStreamDefaultControllerPerformTransform(
           //    controller, chunk).

third_party/blink/renderer/core/streams/writable_stream.cc

@@ -293,7 +293,7 @@ v8::Local<v8::Promise> WritableStream::Abort(ScriptState* script_state,
   }
 
   //  4. Assert: state is "writable" or "erroring".
-  DCHECK(state == kWritable || state == kErroring);
+  CHECK(state == kWritable || state == kErroring);
 
   //  5. Let wasAlreadyErroring be false.
   //  6. If state is "erroring",
@@ -332,7 +332,7 @@ v8::Local<v8::Promise> WritableStream::AddWriteRequest(
   DCHECK(IsLocked(stream));
 
   //  2. Assert: stream.[[state]] is "writable".
-  DCHECK_EQ(stream->state_, kWritable);
+  CHECK_EQ(stream->state_, kWritable);
 
   //  3. Let promise be a new promise.
   auto* promise = MakeGarbageCollected<StreamPromiseResolver>(script_state);
@@ -359,10 +359,10 @@ v8::Local<v8::Promise> WritableStream::Close(ScriptState* script_state,
   }
 
   //  3. Assert: state is "writable" or "erroring".
-  DCHECK(state == kWritable || state == kErroring);
+  CHECK(state == kWritable || state == kErroring);
 
   //  4. Assert: ! WritableStreamCloseQueuedOrInFlight(stream) is false.
-  DCHECK(!CloseQueuedOrInFlight(stream));
+  CHECK(!CloseQueuedOrInFlight(stream));
 
   //  5. Let promise be a new promise.
   auto* promise = MakeGarbageCollected<StreamPromiseResolver>(script_state);
@@ -412,7 +412,7 @@ void WritableStream::DealWithRejection(ScriptState* script_state,
   }
 
   //  3. Assert: state is "erroring".
-  DCHECK_EQ(state, kErroring);
+  CHECK_EQ(state, kErroring);
 
   //  4. Perform ! WritableStreamFinishErroring(stream).
   FinishErroring(script_state, stream);
@@ -426,7 +426,7 @@ void WritableStream::StartErroring(ScriptState* script_state,
   DCHECK(stream->stored_error_.IsEmpty());
 
   //  2. Assert: stream.[[state]] is "writable".
-  DCHECK_EQ(stream->state_, kWritable);
+  CHECK_EQ(stream->state_, kWritable);
 
   //  3. Let controller be stream.[[writableStreamController]].
   WritableStreamDefaultController* controller =
@@ -463,7 +463,7 @@ void WritableStream::FinishErroring(ScriptState* script_state,
                                     WritableStream* stream) {
   // https://streams.spec.whatwg.org/#writable-stream-finish-erroring
   //  1. Assert: stream.[[state]] is "erroring".
-  DCHECK_EQ(stream->state_, kErroring);
+  CHECK_EQ(stream->state_, kErroring);
 
   //  2. Assert: ! WritableStreamHasOperationMarkedInFlight(stream) is false.
   DCHECK(!HasOperationMarkedInFlight(stream));
@@ -611,7 +611,7 @@ void WritableStream::FinishInFlightWriteWithError(ScriptState* script_state,
 
   //  4. Assert: stream.[[state]] is "writable" or "erroring".
   const auto state = stream->state_;
-  DCHECK(state == kWritable || state == kErroring);
+  CHECK(state == kWritable || state == kErroring);
 
   //  5. Perform ! WritableStreamDealWithRejection(stream, error).
   DealWithRejection(script_state, stream, error);
@@ -633,7 +633,7 @@ void WritableStream::FinishInFlightClose(ScriptState* script_state,
   const auto state = stream->state_;
 
   //  5. Assert: stream.[[state]] is "writable" or "erroring".
-  DCHECK(state == kWritable || state == kErroring);
+  CHECK(state == kWritable || state == kErroring);
 
   //  6. If state is "erroring",
   if (state == kErroring) {
@@ -686,7 +686,7 @@ void WritableStream::FinishInFlightCloseWithError(ScriptState* script_state,
 
   //  4. Assert: stream.[[state]] is "writable" or "erroring".
   const auto state = stream->state_;
-  DCHECK(state == kWritable || state == kErroring);
+  CHECK(state == kWritable || state == kErroring);
 
   //  5. If stream.[[pendingAbortRequest]] is not undefined,
   if (stream->pending_abort_request_) {
@@ -740,10 +740,10 @@ void WritableStream::UpdateBackpressure(ScriptState* script_state,
                                         bool backpressure) {
   // https://streams.spec.whatwg.org/#writable-stream-update-backpressure
   //  1. Assert: stream.[[state]] is "writable".
-  DCHECK_EQ(stream->state_, kWritable);
+  CHECK_EQ(stream->state_, kWritable);
 
   //  2. Assert: ! WritableStreamCloseQueuedOrInFlight(stream) is false.
-  DCHECK(!CloseQueuedOrInFlight(stream));
+  CHECK(!CloseQueuedOrInFlight(stream));
 
   //  3. Let writer be stream.[[writer]].
   WritableStreamDefaultWriter* writer = stream->writer_;
@@ -912,7 +912,7 @@ void WritableStream::RejectCloseAndClosedPromiseIfNeeded(
     WritableStream* stream) {
   // https://streams.spec.whatwg.org/#writable-stream-reject-close-and-closed-promise-if-needed
   // //  1. Assert: stream.[[state]] is "errored".
-  DCHECK_EQ(stream->state_, kErrored);
+  CHECK_EQ(stream->state_, kErrored);
 
   auto* isolate = script_state->GetIsolate();
 

third_party/blink/renderer/core/streams/writable_stream_default_controller.cc

@@ -153,8 +153,8 @@ void WritableStreamDefaultController::SetUp(
       // 16. Upon fulfillment of startPromise
       //      a. Assert: stream.[[state]] is "writable" or "erroring".
       const auto state = stream_->GetState();
-      DCHECK(state == WritableStream::kWritable ||
-             state == WritableStream::kErroring);
+      CHECK(state == WritableStream::kWritable ||
+            state == WritableStream::kErroring);
 
       //      b. Set controller.[[started]] to true.
       WritableStreamDefaultController* controller = stream_->Controller();
@@ -184,8 +184,8 @@ void WritableStreamDefaultController::SetUp(
       // 17. Upon rejection of startPromise with reason r,
       //      a. Assert: stream.[[state]] is "writable" or "erroring".
       const auto state = stream_->GetState();
-      DCHECK(state == WritableStream::kWritable ||
-             state == WritableStream::kErroring);
+      CHECK(state == WritableStream::kWritable ||
+            state == WritableStream::kErroring);
 
       //      b. Set controller.[[started]] to true.
       WritableStreamDefaultController* controller = stream_->Controller();
@@ -582,8 +582,8 @@ void WritableStreamDefaultController::ProcessWrite(
       const auto state = stream_->GetState();
 
       //      c. Assert: state is "writable" or "erroring".
-      DCHECK(state == WritableStream::kWritable ||
-             state == WritableStream::kErroring);
+      CHECK(state == WritableStream::kWritable ||
+            state == WritableStream::kErroring);
 
       //      d. Perform ! DequeueValue(controller).
       controller_->queue_->DequeueValue(script_state->GetIsolate());

third_party/blink/renderer/core/streams/writable_stream_default_writer.cc

@@ -326,8 +326,8 @@ v8::Local<v8::Promise> WritableStreamDefaultWriter::CloseWithErrorPropagation(
   }
 
   //  6. Assert: state is "writable" or "erroring".
-  DCHECK(state == WritableStream::kWritable ||
-         state == WritableStream::kErroring);
+  CHECK(state == WritableStream::kWritable ||
+        state == WritableStream::kErroring);
 
   //  7. Return ! WritableStreamDefaultWriterClose(writer).
   return Close(script_state, writer);