Use per-frame TaskRunner instead of thread's default in DataConsumerHandle

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/dom/TaskRunnerHelper.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"
@@ skipping 72 matching lines @@
     }
 
     Member<BodyStreamBuffer> m_buffer;
     Member<FetchDataLoader::Client> m_client;
 };
 
 BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, std::unique_ptr<FetchDataConsumerHandle> handle)
     : UnderlyingSourceBase(scriptState)
     , m_scriptState(scriptState)
     , m_handle(std::move(handle))
-    , m_reader(m_handle->obtainFetchDataReader(this))
+    , m_reader(m_handle->obtainFetchDataReader(this, TaskRunnerHelper::getUnthrottledTaskRunner(scriptState)->clone()))
     , m_madeFromReadableStream(false)
 {
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
         if (isTerminating(scriptState)) {
             m_reader = nullptr;
             m_handle = nullptr;
             return;
         }
         v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
         if (bodyValue.IsEmpty()) {
@@ skipping 92 matching lines @@
     }
     return nullptr;
 }
 
 void BodyStreamBuffer::startLoading(FetchDataLoader* loader, FetchDataLoader::Client* client)
 {
     ASSERT(!m_loader);
     ASSERT(m_scriptState->contextIsValid());
     std::unique_ptr<FetchDataConsumerHandle> handle = releaseHandle();
     m_loader = loader;
-    loader->start(handle.get(), new LoaderClient(m_scriptState->getExecutionContext(), this, client));
+    loader->start(handle.get(), new LoaderClient(m_scriptState->getExecutionContext(), this, client), TaskRunnerHelper::getUnthrottledTaskRunner(m_scriptState.get())->clone());
 }
 
 void BodyStreamBuffer::tee(BodyStreamBuffer** branch1, BodyStreamBuffer** branch2)
 {
     DCHECK(!isStreamLocked());
     DCHECK(!isStreamDisturbed());
     *branch1 = nullptr;
     *branch2 = nullptr;
 
     if (m_madeFromReadableStream) {
@@ skipping 248 matching lines @@
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
     }
     if (isErrored)
         return createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle());
 
     DCHECK(handle);
     return handle;
 }
 
 } // namespace blink