[Fetch API] Do not call v8 Extra script when the worker is terminating

third_party/WebKit/Source/modules/fetch/BodyStreamBuffer.cpp

 // Copyright 2014 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/BodyStreamBuffer.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8HiddenValue.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/streams/ReadableStreamController.h"
 #include "core/streams/ReadableStreamOperations.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/DataConsumerTee.h"
 #include "modules/fetch/ReadableStreamDataConsumerHandle.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/EncodedFormData.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
+
 class BodyStreamBuffer::LoaderClient final : public GarbageCollectedFinalized<LoaderClient>, public ActiveDOMObject, public FetchDataLoader::Client {
     WTF_MAKE_NONCOPYABLE(LoaderClient);
     USING_GARBAGE_COLLECTED_MIXIN(LoaderClient);
 public:
     LoaderClient(ExecutionContext* executionContext, BodyStreamBuffer* buffer, FetchDataLoader::Client* client)
         : ActiveDOMObject(executionContext)
         , m_buffer(buffer)
         , m_client(client)
     {
         suspendIfNeeded();
@@ skipping 49 matching lines @@
 
 BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, PassOwnPtr<FetchDataConsumerHandle> handle)
     : UnderlyingSourceBase(scriptState)
     , m_scriptState(scriptState)
     , m_handle(std::move(handle))
     , m_reader(m_handle->obtainReader(this))
     , m_madeFromReadableStream(false)
 {
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
         ScriptState::Scope scope(scriptState);
+        if (isTerminating(scriptState))
+            return;
         v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
-        ASSERT(!bodyValue.IsEmpty());
+        if (bodyValue.IsEmpty()) {
+            DCHECK(isTerminating(scriptState));
+            return;
+        }
         ASSERT(bodyValue->IsObject());
         v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
 
         ScriptValue readableStream = ReadableStreamOperations::createReadableStream(
             scriptState, this, ReadableStreamOperations::createCountQueuingStrategy(scriptState, 0));
         V8HiddenValue::setHiddenValue(scriptState, body, V8HiddenValue::internalBodyStream(scriptState->isolate()), readableStream.v8Value());
     } else {
         m_stream = new ReadableByteStream(this, new ReadableByteStream::StrictStrategy);
         m_stream->didSourceStart();
     }
 }
 
 BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, ScriptValue stream)
     : UnderlyingSourceBase(scriptState)
     , m_scriptState(scriptState)
     , m_madeFromReadableStream(true)
 {
     ScriptState::Scope scope(scriptState);
     DCHECK(RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled());
     DCHECK(ReadableStreamOperations::isReadableStream(scriptState, stream));
+    if (isTerminating(scriptState))
+        return;
     v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
-    DCHECK(!bodyValue.IsEmpty());
+    if (bodyValue.IsEmpty()) {
+        DCHECK(isTerminating(scriptState));
+        return;
+    }
     DCHECK(bodyValue->IsObject());
     v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
 
     V8HiddenValue::setHiddenValue(scriptState, body, V8HiddenValue::internalBodyStream(scriptState->isolate()), stream.v8Value());
 }
 
 ScriptValue BodyStreamBuffer::stream()
 {
     ScriptState::Scope scope(m_scriptState.get());
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
+        if (isTerminating(m_scriptState.get()))
+            return ScriptValue();
         v8::Local<v8::Value> bodyValue = toV8(this, m_scriptState.get());
-        ASSERT(!bodyValue.IsEmpty());
+        if (bodyValue.IsEmpty()) {
+            DCHECK(isTerminating(m_scriptState.get()));
+            return ScriptValue();
+        }
         ASSERT(bodyValue->IsObject());
         v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
         return ScriptValue(m_scriptState.get(), V8HiddenValue::getHiddenValue(m_scriptState.get(), body, V8HiddenValue::internalBodyStream(m_scriptState->isolate())));
     }
     return ScriptValue(m_scriptState.get(), toV8(m_stream, m_scriptState.get()));
 }
 
 PassRefPtr<BlobDataHandle> BodyStreamBuffer::drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::BlobSizePolicy policy)
 {
     ASSERT(!isStreamLocked());
@@ skipping 299 matching lines @@
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
     }
     if (isErrored)
         return createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle());
 
     DCHECK(handle);
     return handle;
 }
 
 } // namespace blink