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

third_party/WebKit/Source/modules/fetch/FetchBlobDataConsumerHandle.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/FetchBlobDataConsumerHandle.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "modules/fetch/CompositeDataConsumerHandle.h"
 #include "modules/fetch/CrossThreadHolder.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "platform/blob/BlobRegistry.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/network/ResourceRequest.h"
+#include "public/platform/WebTaskRunner.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 using Result = FetchBlobDataConsumerHandle::Result;
 
 namespace {
 
 // Object graph:
@@ skipping 148 matching lines @@
 } // namespace
 
 // ReaderContext is referenced from FetchBlobDataConsumerHandle and
 // ReaderContext::ReaderImpl.
 // All functions/members must be called/accessed only on the reader thread,
 // except for constructor, destructor, and obtainReader().
 class FetchBlobDataConsumerHandle::ReaderContext final : public ThreadSafeRefCounted<ReaderContext> {
 public:
     class ReaderImpl : public FetchDataConsumerHandle::Reader {
     public:
-        ReaderImpl(Client* client, PassRefPtr<ReaderContext> readerContext, std::unique_ptr<WebDataConsumerHandle::Reader> reader)
+        ReaderImpl(Client* client, PassRefPtr<ReaderContext> readerContext, std::unique_ptr<WebDataConsumerHandle::Reader> reader, std::unique_ptr<WebTaskRunner> readerTaskRunner)
             : m_readerContext(readerContext)
             , m_reader(std::move(reader))
-            , m_notifier(client) { }
+            , m_notifier(client, readerTaskRunner.get()) { }
         ~ReaderImpl() override { }
 
         Result read(void* data, size_t size, Flags flags, size_t* readSize) override
         {
             if (m_readerContext->drained())
                 return Done;
             m_readerContext->ensureStartLoader();
             Result r = m_reader->read(data, size, flags, readSize);
             if (!(size == 0 && (r == Ok || r == ShouldWait))) {
                 // We read non-empty data, so we cannot use the blob data
@@ skipping 48 matching lines @@
     ReaderContext(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle, FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
         : m_blobDataHandleForDrain(blobDataHandle)
         , m_loaderStarted(false)
         , m_drained(false)
     {
         CompositeDataConsumerHandle::Updater* updater = nullptr;
         m_handle = CompositeDataConsumerHandle::create(createWaitingDataConsumerHandle(), &updater);
         m_loaderContextHolder = CrossThreadHolder<LoaderContext>::create(executionContext, wrapUnique(new BlobLoaderContext(updater, m_blobDataHandleForDrain, loaderFactory)));
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> obtainReader(WebDataConsumerHandle::Client* client)
+    std::unique_ptr<FetchDataConsumerHandle::Reader> obtainReader(WebDataConsumerHandle::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner)
     {
-        return wrapUnique(new ReaderImpl(client, this, m_handle->obtainReader(client)));
+        return wrapUnique(new ReaderImpl(client, this, m_handle->obtainReader(client, readerTaskRunner->clone()), readerTaskRunner->clone()));
     }
 
 private:
     void ensureStartLoader()
     {
         if (m_loaderStarted)
             return;
         m_loaderStarted = true;
         m_loaderContextHolder->postTask(crossThreadBind(&LoaderContext::start));
     }
@@ skipping 32 matching lines @@
 }
 
 std::unique_ptr<FetchDataConsumerHandle> FetchBlobDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle)
 {
     if (!blobDataHandle)
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
 
     return wrapUnique(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, new DefaultLoaderFactory));
 }
 
-std::unique_ptr<FetchDataConsumerHandle::Reader> FetchBlobDataConsumerHandle::obtainFetchDataReader(Client* client)
+std::unique_ptr<FetchDataConsumerHandle::Reader> FetchBlobDataConsumerHandle::obtainFetchDataReader(Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner)
 {
-    return m_readerContext->obtainReader(client);
+    return m_readerContext->obtainReader(client, std::move(readerTaskRunner));
 }
 
 } // namespace blink