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 23 matching lines @@
         : ActiveDOMObject(executionContext)
         , m_buffer(buffer)
         , m_client(client)
     {
         suspendIfNeeded();
     }
 
     void didFetchDataLoadedBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle) override
     {
         m_buffer->endLoading();
-        m_client->didFetchDataLoadedBlobHandle(blobDataHandle);
+        if (m_client)
+            m_client->didFetchDataLoadedBlobHandle(blobDataHandle);
     }
 
     void didFetchDataLoadedArrayBuffer(DOMArrayBuffer* arrayBuffer) override
     {
         m_buffer->endLoading();
-        m_client->didFetchDataLoadedArrayBuffer(arrayBuffer);
+        if (m_client)
+            m_client->didFetchDataLoadedArrayBuffer(arrayBuffer);
     }
 
     void didFetchDataLoadedString(const String& string) override
     {
         m_buffer->endLoading();
-        m_client->didFetchDataLoadedString(string);
+        if (m_client)
+            m_client->didFetchDataLoadedString(string);
     }
 
     void didFetchDataLoadedStream() override
     {
         m_buffer->endLoading();
-        m_client->didFetchDataLoadedStream();
+        if (m_client)
+            m_client->didFetchDataLoadedStream();
     }
 
     void didFetchDataLoadFailed() override
     {
         m_buffer->endLoading();
-        m_client->didFetchDataLoadFailed();
+        if (m_client)
+            m_client->didFetchDataLoadFailed();
+    }
+
+    WebTaskRunner* getTaskRunner() override
+    {
+        return m_client ? m_client->getTaskRunner() : TaskRunnerHelper::getUnthrottledTaskRunner(getExecutionContext());
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_buffer);
         visitor->trace(m_client);
         ActiveDOMObject::trace(visitor);
         FetchDataLoader::Client::trace(visitor);
     }
 
@@ skipping 198 matching lines @@
         case WebDataConsumerHandle::ResourceExhausted:
         case WebDataConsumerHandle::UnexpectedError:
             error();
             return;
         }
         return;
     }
     processData();
 }
 
+WebTaskRunner* BodyStreamBuffer::getTaskRunner()
+{
+    return TaskRunnerHelper::getUnthrottledTaskRunner(scriptState());
+}
+
 bool BodyStreamBuffer::hasPendingActivity() const
 {
     if (m_loader)
         return true;
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled())
         return UnderlyingSourceBase::hasPendingActivity();
 
     return m_stream->stateInternal() == ReadableStream::Readable && m_stream->isLocked();
 }
 
@@ skipping 168 matching lines @@
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
     }
     if (isErrored)
         return createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle());
 
     DCHECK(handle);
     return handle;
 }
 
 } // namespace blink