Revert of Streams: Remove isTerminating() calls

third_party/WebKit/Source/modules/fetch/ReadableStreamDataConsumerHandle.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 "modules/fetch/ReadableStreamDataConsumerHandle.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8IteratorResultValue.h"
 #include "bindings/core/v8/V8Uint8Array.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/streams/ReadableStreamOperations.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
 #include "wtf/RefCounted.h"
 #include <algorithm>
 #include <string.h>
 #include <v8.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
+
 using Result = WebDataConsumerHandle::Result;
 using Flags = WebDataConsumerHandle::Flags;
 
 // This context is not yet thread-safe.
 class ReadableStreamDataConsumerHandle::ReadingContext final : public RefCounted<ReadingContext> {
     WTF_MAKE_NONCOPYABLE(ReadingContext);
 public:
     class OnFulfilled final : public ScriptFunction {
     public:
         static v8::Local<v8::Function> createFunction(ScriptState* scriptState, PassRefPtr<ReadingContext> context)
         {
             return (new OnFulfilled(scriptState, context))->bindToV8Function();
         }
 
         ScriptValue call(ScriptValue v) override
         {
             RefPtr<ReadingContext> readingContext(m_readingContext);
             if (!readingContext)
                 return v;
             bool done;
             v8::Local<v8::Value> item = v.v8Value();
             ASSERT(item->IsObject());
+            if (isTerminating(v.getScriptState()))
+                return ScriptValue();
             v8::MaybeLocal<v8::Value> maybeValue = v8UnpackIteratorResult(v.getScriptState(), item.As<v8::Object>(), &done);
+            if (isTerminating(v.getScriptState()))
+                return ScriptValue();
             v8::Local<v8::Value> value = maybeValue.ToLocalChecked();
             if (done) {
                 readingContext->onReadDone();
                 return v;
             }
             if (!value->IsUint8Array()) {
                 readingContext->onRejected();
                 return ScriptValue();
             }
             readingContext->onRead(V8Uint8Array::toImpl(value.As<v8::Object>()));
@@ skipping 209 matching lines @@
 {
 }
 ReadableStreamDataConsumerHandle::~ReadableStreamDataConsumerHandle() = default;
 
 std::unique_ptr<FetchDataConsumerHandle::Reader> ReadableStreamDataConsumerHandle::obtainFetchDataReader(Client* client)
 {
     return WTF::wrapUnique(new ReadingContext::ReaderImpl(m_readingContext, client));
 }
 
 } // namespace blink