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

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

Index: third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
diff --git a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
index 2506af4e00842c49be6d5ccd8afc48e7940f5f76..b4814e2ca23ec5a0481d1b9765983d44a709ec43 100644
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
@@ -60,6 +60,7 @@ public:
         ~Thread();
 
         WebThreadSupportingGC* thread() { return m_thread.get(); }
+        WebTaskRunner* taskRunner() { return m_thread->platformThread().getWebTaskRunner(); }
         ExecutionContext* getExecutionContext() { return m_executionContext.get(); }
         ScriptState* getScriptState() { return m_scriptState.get(); }
         v8::Isolate* isolate() { return m_isolateHolder->isolate(); }
@@ -127,6 +128,11 @@ public:
                 m_holder->updatingThread()->postTask(location, std::move(task));
             }
 
+            WebTaskRunner* getReadingThreadTaskRunner()
+            {
+                return m_holder->readingThread()->platformThread().getWebTaskRunner();
+            }
+
         private:
             Context()
                 : m_holder(nullptr) { }
@@ -207,7 +213,10 @@ public:
         private:
             DataConsumerHandle(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context) { }
 
-            std::unique_ptr<Reader> obtainReader(Client*) { return WTF::wrapUnique(new ReaderImpl(m_name, m_context)); }
+            std::unique_ptr<Reader> obtainReader(Client*, std::unique_ptr<WebTaskRunner>)
+            {
+                return WTF::wrapUnique(new ReaderImpl(m_name, m_context));
+            }
             const char* debugName() const override { return "ThreadingTestBase::DataConsumerHandle"; }
 
             const String m_name;
@@ -263,7 +272,7 @@ public:
         ThreadingHandleNotificationTest() = default;
         void obtainReader()
         {
-            m_reader = m_handle->obtainReader(this);
+            m_reader = m_handle->obtainReader(this, m_context->getReadingThreadTaskRunner()->clone());
         }
         void didGetReadable() override
         {
@@ -292,7 +301,7 @@ public:
         ThreadingHandleNoNotificationTest() = default;
         void obtainReader()
         {
-            m_reader = m_handle->obtainReader(this);
+            m_reader = m_handle->obtainReader(this, m_context->getReadingThreadTaskRunner()->clone());
             m_reader = nullptr;
             postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
         }
@@ -307,7 +316,12 @@ public:
     class MockFetchDataConsumerHandle : public FetchDataConsumerHandle {
     public:
         static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
-        MOCK_METHOD1(obtainFetchDataReader, std::unique_ptr<Reader>(Client*));
+        MOCK_METHOD1(obtainFetchDataReaderMock, std::unique_ptr<Reader>(Client*));
+
+        std::unique_ptr<Reader> obtainFetchDataReader(Client* client, std::unique_ptr<WebTaskRunner>)
+        {
+            return obtainFetchDataReaderMock(client);
+        }
 
     private:
         const char* debugName() const override { return "MockFetchDataConsumerHandle"; }
@@ -401,7 +415,7 @@ public:
 
             // This function cannot be called after creating a tee.
             void add(const Command&);
-            void attachReader(WebDataConsumerHandle::Client*);
+            void attachReader(WebDataConsumerHandle::Client*, std::unique_ptr<WebTaskRunner>);
             void detachReader();
             void detachHandle();
             Result beginRead(const void** buffer, Flags, size_t* available);
@@ -419,7 +433,7 @@ public:
 
             Deque<Command> m_commands;
             size_t m_offset;
-            WebThread* m_readerThread;
+            std::unique_ptr<WebTaskRunner> m_readerTaskRunner;
             Client* m_client;
             Result m_result;
             bool m_isHandleAttached;
@@ -428,7 +442,7 @@ public:
         };
 
         Context* getContext() { return m_context.get(); }
-        std::unique_ptr<Reader> obtainReader(Client*) override;
+        std::unique_ptr<Reader> obtainReader(Client*, std::unique_ptr<WebTaskRunner>) override;
 
     private:
         class ReaderImpl;
@@ -459,12 +473,13 @@ public:
     public:
         using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
 
-        HandleReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+        HandleReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>, std::unique_ptr<WebTaskRunner> readerTaskRunner);
         void didGetReadable() override;
 
     private:
         void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
 
+        std::unique_ptr<WebTaskRunner> m_readerTaskRunner;
         std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         std::unique_ptr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
@@ -477,12 +492,13 @@ public:
     public:
         using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
 
-        HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+        HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>, std::unique_ptr<WebTaskRunner>);
         void didGetReadable() override;
 
     private:
         void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
 
+        std::unique_ptr<WebTaskRunner> m_readerTaskRunner;
         std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         std::unique_ptr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
@@ -499,7 +515,7 @@ public:
             , m_event(wrapUnique(new WaitableEvent()))
             , m_isDone(false)
         {
-            m_thread->thread()->postTask(BLINK_FROM_HERE, crossThreadBind(&HandleReaderRunner::start, crossThreadUnretained(this), passed(std::move(handle))));
+            m_thread->thread()->postTask(BLINK_FROM_HERE, crossThreadBind(&HandleReaderRunner::start, crossThreadUnretained(this), passed(std::move(handle)), passed(m_thread->taskRunner()->clone())));
         }
         ~HandleReaderRunner()
         {
@@ -516,9 +532,9 @@ public:
         }
 
     private:
-        void start(std::unique_ptr<WebDataConsumerHandle> handle)
+        void start(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<WebTaskRunner> readerTaskRunner)
         {
-            m_handleReader = wrapUnique(new T(std::move(handle), WTF::bind(&HandleReaderRunner::onFinished, WTF::unretained(this))));
+            m_handleReader = wrapUnique(new T(std::move(handle), WTF::bind(&HandleReaderRunner::onFinished, WTF::unretained(this)), std::move(readerTaskRunner)));
         }
 
         void onFinished(std::unique_ptr<HandleReadResult> result)
@@ -537,6 +553,8 @@ public:
     };
 };
 
+std::unique_ptr<WebTaskRunner> getCurrentTaskRunner();
+
 } // namespace blink
 
 #endif // DataConsumerHandleTestUtil_h