Remove isTerminating checks from ReadableStreamOperations

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/ScriptState.h"
 #include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
-#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/streams/UnderlyingSourceBase.h"
-#include "core/workers/WorkerGlobalScope.h"
 
 namespace blink {
 
-namespace {
-
-bool isTerminating(ScriptState* scriptState)
-{
-    ExecutionContext* executionContext = scriptState->getExecutionContext();
-    if (!executionContext)
-        return true;
-    if (!executionContext->isWorkerGlobalScope())
-        return false;
-    return toWorkerGlobalScope(executionContext)->scriptController()->isExecutionTerminating();
-}
-
-} // namespace
-
 ScriptValue ReadableStreamOperations::createReadableStream(ScriptState* scriptState, UnderlyingSourceBase* underlyingSource, ScriptValue strategy)
 {
-    if (isTerminating(scriptState))
-        return ScriptValue();
     ScriptState::Scope scope(scriptState);
 
     v8::Local<v8::Value> jsUnderlyingSource = toV8(underlyingSource, scriptState);
     v8::Local<v8::Value> jsStrategy = strategy.v8Value();
     v8::Local<v8::Value> args[] = { jsUnderlyingSource, jsStrategy };
-    v8::MaybeLocal<v8::Value> jsStream = V8ScriptRunner::callExtra(scriptState, "createReadableStreamWithExternalController", args);
-    if (isTerminating(scriptState))
-        return ScriptValue();
-    return ScriptValue(scriptState, jsStream.ToLocalChecked());
+    return ScriptValue(scriptState, V8ScriptRunner::callExtraOrCrash(scriptState, "createReadableStreamWithExternalController", args));
 }
 
 ScriptValue ReadableStreamOperations::createCountQueuingStrategy(ScriptState* scriptState, size_t highWaterMark)
 {
-    if (isTerminating(scriptState))
-        return ScriptValue();
     ScriptState::Scope scope(scriptState);
 
     v8::Local<v8::Value> args[] = { v8::Number::New(scriptState->isolate(), highWaterMark) };
-    v8::MaybeLocal<v8::Value> jsStrategy = V8ScriptRunner::callExtra(scriptState, "createBuiltInCountQueuingStrategy", args);
-    if (isTerminating(scriptState))
-        return ScriptValue();
-
-    return ScriptValue(scriptState, jsStrategy.ToLocalChecked());
+    return ScriptValue(scriptState, V8ScriptRunner::callExtraOrCrash(scriptState, "createBuiltInCountQueuingStrategy", args));
 }
 
 ScriptValue ReadableStreamOperations::getReader(ScriptState* scriptState, ScriptValue stream, ExceptionState& es)
 {
-    if (isTerminating(scriptState))
-        return ScriptValue();
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::TryCatch block(scriptState->isolate());
     v8::Local<v8::Value> args[] = { stream.v8Value() };
     ScriptValue result(scriptState, V8ScriptRunner::callExtra(scriptState, "AcquireReadableStreamDefaultReader", args));
     if (block.HasCaught())
         es.rethrowV8Exception(block.Exception());
     return result;
 }
 
 bool ReadableStreamOperations::isReadableStream(ScriptState* scriptState, ScriptValue value)
 {
-    if (isTerminating(scriptState))
-        return true;
     ASSERT(!value.isEmpty());
 
     if (!value.isObject())
         return false;
 
     v8::Local<v8::Value> args[] = { value.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStream", args);
-    if (isTerminating(scriptState))
-        return true;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStream", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isDisturbed(ScriptState* scriptState, ScriptValue stream)
 {
-    if (isTerminating(scriptState))
-        return true;
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStreamDisturbed", args);
-    if (isTerminating(scriptState))
-        return true;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamDisturbed", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isLocked(ScriptState* scriptState, ScriptValue stream)
 {
-    if (isTerminating(scriptState))
-        return true;
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStreamLocked", args);
-    if (isTerminating(scriptState))
-        return true;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamLocked", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isReadable(ScriptState* scriptState, ScriptValue stream)
 {
-    if (isTerminating(scriptState))
-        return false;
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamReadable", args);
-    if (isTerminating(scriptState))
-        return false;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamReadable", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isClosed(ScriptState* scriptState, ScriptValue stream)
 {
-    if (isTerminating(scriptState))
-        return false;
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStreamClosed", args);
-    if (isTerminating(scriptState))
-        return false;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamClosed", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isErrored(ScriptState* scriptState, ScriptValue stream)
 {
-    if (isTerminating(scriptState))
-        return true;
     ASSERT(isReadableStream(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStreamErrored", args);
-    if (isTerminating(scriptState))
-        return true;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamErrored", args)->ToBoolean()->Value();
 }
 
 bool ReadableStreamOperations::isReadableStreamDefaultReader(ScriptState* scriptState, ScriptValue value)
 {
-    if (isTerminating(scriptState))
-        return true;
     ASSERT(!value.isEmpty());
 
     if (!value.isObject())
         return false;
 
     v8::Local<v8::Value> args[] = { value.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "IsReadableStreamDefaultReader", args);
-    if (isTerminating(scriptState))
-        return true;
-    return result.ToLocalChecked()->ToBoolean()->Value();
+    return V8ScriptRunner::callExtraOrCrash(scriptState, "IsReadableStreamDefaultReader", args)->ToBoolean()->Value();
 }
 
 ScriptPromise ReadableStreamOperations::defaultReaderRead(ScriptState* scriptState, ScriptValue reader)
 {
-    if (isTerminating(scriptState))
-        return ScriptPromise();
     ASSERT(isReadableStreamDefaultReader(scriptState, reader));
 
     v8::Local<v8::Value> args[] = { reader.v8Value() };
-    v8::MaybeLocal<v8::Value> result = V8ScriptRunner::callExtra(scriptState, "ReadableStreamDefaultReaderRead", args);
-    if (isTerminating(scriptState))
-        return ScriptPromise();
-    return ScriptPromise::cast(scriptState, result.ToLocalChecked());
+    return ScriptPromise::cast(scriptState, V8ScriptRunner::callExtraOrCrash(scriptState, "ReadableStreamDefaultReaderRead", args));
 }
 
 void ReadableStreamOperations::tee(ScriptState* scriptState, ScriptValue stream, ScriptValue* newStream1, ScriptValue* newStream2)
 {
-    if (isTerminating(scriptState))
-        return;
     DCHECK(isReadableStream(scriptState, stream));
     DCHECK(!isLocked(scriptState, stream));
 
     v8::Local<v8::Value> args[] = { stream.v8Value() };
 
-    v8::MaybeLocal<v8::Value> maybeResult = V8ScriptRunner::callExtra(scriptState, "ReadableStreamTee", args);
-    if (isTerminating(scriptState))
-        return;
-    ScriptValue result(scriptState, maybeResult.ToLocalChecked());
+    ScriptValue result(scriptState, V8ScriptRunner::callExtraOrCrash(scriptState, "ReadableStreamTee", args));
     DCHECK(result.v8Value()->IsArray());
     v8::Local<v8::Array> branches = result.v8Value().As<v8::Array>();
     DCHECK_EQ(2u, branches->Length());
 
-    v8::MaybeLocal<v8::Value> maybeStream1 = branches->Get(scriptState->context(), 0);
-    if (isTerminating(scriptState))
-        return;
-    v8::MaybeLocal<v8::Value> maybeStream2 = branches->Get(scriptState->context(), 1);
-    if (isTerminating(scriptState))
-        return;
-
-    *newStream1 = ScriptValue(scriptState, maybeStream1.ToLocalChecked());
-    *newStream2 = ScriptValue(scriptState, maybeStream2.ToLocalChecked());
+    *newStream1 = ScriptValue(scriptState, branches->Get(scriptState->context(), 0).ToLocalChecked());
+    *newStream2 = ScriptValue(scriptState, branches->Get(scriptState->context(), 1).ToLocalChecked());
 
     DCHECK(isReadableStream(scriptState, *newStream1));
     DCHECK(isReadableStream(scriptState, *newStream2));
 }
 
 } // namespace blink