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

third_party/WebKit/Source/modules/fetch/FetchDataLoader.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/FetchDataLoader.h"
 
 #include "core/html/parser/TextResourceDecoder.h"
+#include "public/platform/WebTaskRunner.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferBuilder.h"
 #include <memory>
+#include <utility>
 
 namespace blink {
 
 namespace {
 
 class FetchDataLoaderAsBlobHandle
     : public FetchDataLoader
     , public WebDataConsumerHandle::Client {
 public:
     explicit FetchDataLoaderAsBlobHandle(const String& mimeType)
         : m_client(nullptr)
         , m_mimeType(mimeType) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 private:
-    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner) override
     {
         ASSERT(!m_client);
         ASSERT(!m_reader);
 
         m_client = client;
         // Passing |this| here is safe because |this| owns |m_reader|.
-        m_reader = handle->obtainFetchDataReader(this);
+        m_reader = handle->obtainFetchDataReader(this, std::move(readerTaskRunner));
         RefPtr<BlobDataHandle> blobHandle = m_reader->drainAsBlobDataHandle();
         if (blobHandle) {
             ASSERT(blobHandle->size() != UINT64_MAX);
             m_reader.reset();
             if (blobHandle->type() != m_mimeType) {
                 // A new BlobDataHandle is created to override the Blob's type.
                 m_client->didFetchDataLoadedBlobHandle(BlobDataHandle::create(blobHandle->uuid(), m_mimeType, blobHandle->size()));
             } else {
                 m_client->didFetchDataLoadedBlobHandle(blobHandle);
             }
@@ skipping 66 matching lines @@
     FetchDataLoaderAsArrayBuffer()
         : m_client(nullptr) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 protected:
-    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner) override
     {
         ASSERT(!m_client);
         ASSERT(!m_rawData);
         ASSERT(!m_reader);
         m_client = client;
         m_rawData = wrapUnique(new ArrayBufferBuilder());
-        m_reader = handle->obtainFetchDataReader(this);
+        m_reader = handle->obtainFetchDataReader(this, std::move(readerTaskRunner));
     }
 
     void didGetReadable() override
     {
         ASSERT(m_client);
         ASSERT(m_rawData);
         ASSERT(m_reader);
 
         while (true) {
             const void* buffer;
@@ skipping 61 matching lines @@
     FetchDataLoaderAsString()
         : m_client(nullptr) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 protected:
-    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner) override
     {
         ASSERT(!m_client);
         ASSERT(!m_decoder);
         ASSERT(!m_reader);
         m_client = client;
         m_decoder = TextResourceDecoder::createAlwaysUseUTF8ForText();
-        m_reader = handle->obtainFetchDataReader(this);
+        m_reader = handle->obtainFetchDataReader(this, std::move(readerTaskRunner));
     }
 
     void didGetReadable() override
     {
         ASSERT(m_client);
         ASSERT(m_decoder);
         ASSERT(m_reader);
 
         while (true) {
             const void* buffer;
@@ skipping 61 matching lines @@
         , m_outStream(outStream) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
         visitor->trace(m_outStream);
     }
 
 protected:
-    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner) override
     {
         ASSERT(!m_client);
         ASSERT(!m_reader);
         m_client = client;
-        m_reader = handle->obtainFetchDataReader(this);
+        m_reader = handle->obtainFetchDataReader(this, std::move(readerTaskRunner));
     }
 
     void didGetReadable() override
     {
         ASSERT(m_client);
         ASSERT(m_reader);
 
         bool needToFlush = false;
         while (true) {
             const void* buffer;
@@ skipping 73 matching lines @@
 {
     return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream)
 {
     return new FetchDataLoaderAsStream(outStream);
 }
 
 } // namespace blink