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

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

Index: third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
diff --git a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
index 21f39da4c2f0a800a93040e89c1073e7d1ef4f33..ccaee177d9203b01b1139c6f385cdfdb6cb12f2d 100644
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
@@ -60,10 +60,10 @@ void DataConsumerHandleTestUtil::Thread::shutdown()
 
 class DataConsumerHandleTestUtil::ReplayingHandle::ReaderImpl final : public Reader {
 public:
-    ReaderImpl(PassRefPtr<Context> context, Client* client)
+    ReaderImpl(PassRefPtr<Context> context, Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner)
         : m_context(context)
     {
-        m_context->attachReader(client);
+        m_context->attachReader(client, std::move(readerTaskRunner));
     }
     ~ReaderImpl()
     {
@@ -89,12 +89,12 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::add(const Command& co
     m_commands.append(command);
 }
 
-void DataConsumerHandleTestUtil::ReplayingHandle::Context::attachReader(WebDataConsumerHandle::Client* client)
+void DataConsumerHandleTestUtil::ReplayingHandle::Context::attachReader(WebDataConsumerHandle::Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner)
 {
     MutexLocker locker(m_mutex);
-    DCHECK(!m_readerThread);
+    DCHECK(!m_readerTaskRunner);
     DCHECK(!m_client);
-    m_readerThread = Platform::current()->currentThread();
+    m_readerTaskRunner = std::move(readerTaskRunner);
     m_client = client;
 
     if (m_client && !(isEmpty() && m_result == ShouldWait))
@@ -104,8 +104,8 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::attachReader(WebDataC
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::detachReader()
 {
     MutexLocker locker(m_mutex);
-    DCHECK(m_readerThread && m_readerThread->isCurrentThread());
-    m_readerThread = nullptr;
+    DCHECK(m_readerTaskRunner && m_readerTaskRunner->runsTasksOnCurrentThread());
+    m_readerTaskRunner = nullptr;
     m_client = nullptr;
     if (!m_isHandleAttached)
         m_detached->signal();
@@ -115,7 +115,7 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::detachHandle()
 {
     MutexLocker locker(m_mutex);
     m_isHandleAttached = false;
-    if (!m_readerThread)
+    if (!m_readerTaskRunner)
         m_detached->signal();
 }
 
@@ -163,7 +163,7 @@ WebDataConsumerHandle::Result DataConsumerHandleTestUtil::ReplayingHandle::Conte
 
 DataConsumerHandleTestUtil::ReplayingHandle::Context::Context()
     : m_offset(0)
-    , m_readerThread(nullptr)
+    , m_readerTaskRunner(nullptr)
     , m_client(nullptr)
     , m_result(ShouldWait)
     , m_isHandleAttached(true)
@@ -194,15 +194,15 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::notify()
 {
     if (!m_client)
         return;
-    DCHECK(m_readerThread);
-    m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&Context::notifyInternal, wrapPassRefPtr(this)));
+    DCHECK(m_readerTaskRunner);
+    m_readerTaskRunner->postTask(BLINK_FROM_HERE, crossThreadBind(&Context::notifyInternal, wrapPassRefPtr(this)));
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::notifyInternal()
 {
     {
         MutexLocker locker(m_mutex);
-        if (!m_client || !m_readerThread->isCurrentThread()) {
+        if (!m_client || !m_readerTaskRunner->runsTasksOnCurrentThread()) {
             // There is no client, or a new reader is attached.
             return;
         }
@@ -221,9 +221,9 @@ DataConsumerHandleTestUtil::ReplayingHandle::~ReplayingHandle()
     m_context->detachHandle();
 }
 
-std::unique_ptr<WebDataConsumerHandle::Reader> DataConsumerHandleTestUtil::ReplayingHandle::obtainReader(Client* client)
+std::unique_ptr<WebDataConsumerHandle::Reader> DataConsumerHandleTestUtil::ReplayingHandle::obtainReader(Client* client, std::unique_ptr<WebTaskRunner> readerTaskRunner)
 {
-    return WTF::wrapUnique(new ReaderImpl(m_context, client));
+    return WTF::wrapUnique(new ReaderImpl(m_context, client, std::move(readerTaskRunner)));
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::add(const Command& command)
@@ -231,8 +231,9 @@ void DataConsumerHandleTestUtil::ReplayingHandle::add(const Command& command)
     m_context->add(command);
 }
 
-DataConsumerHandleTestUtil::HandleReader::HandleReader(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<OnFinishedReading> onFinishedReading)
-    : m_reader(handle->obtainReader(this))
+DataConsumerHandleTestUtil::HandleReader::HandleReader(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<OnFinishedReading> onFinishedReading, std::unique_ptr<WebTaskRunner> readerTaskRunner)
+    : m_readerTaskRunner(std::move(readerTaskRunner))
+    , m_reader(handle->obtainReader(this, m_readerTaskRunner->clone()))
     , m_onFinishedReading(std::move(onFinishedReading))
 {
 }
@@ -252,7 +253,7 @@ void DataConsumerHandleTestUtil::HandleReader::didGetReadable()
     }
     std::unique_ptr<HandleReadResult> result = wrapUnique(new HandleReadResult(r, m_data));
     m_data.clear();
-    Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, WTF::bind(&HandleReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
+    m_readerTaskRunner->postTask(BLINK_FROM_HERE, WTF::bind(&HandleReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
     m_reader = nullptr;
 }
 
@@ -263,8 +264,9 @@ void DataConsumerHandleTestUtil::HandleReader::runOnFinishedReading(std::unique_
     (*onFinishedReading)(std::move(result));
 }
 
-DataConsumerHandleTestUtil::HandleTwoPhaseReader::HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<OnFinishedReading> onFinishedReading)
-    : m_reader(handle->obtainReader(this))
+DataConsumerHandleTestUtil::HandleTwoPhaseReader::HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<OnFinishedReading> onFinishedReading, std::unique_ptr<WebTaskRunner> readerTaskRunner)
+    : m_readerTaskRunner(std::move(readerTaskRunner))
+    , m_reader(handle->obtainReader(this, m_readerTaskRunner->clone()))
     , m_onFinishedReading(std::move(onFinishedReading))
 {
 }
@@ -287,7 +289,7 @@ void DataConsumerHandleTestUtil::HandleTwoPhaseReader::didGetReadable()
     }
     std::unique_ptr<HandleReadResult> result = wrapUnique(new HandleReadResult(r, m_data));
     m_data.clear();
-    Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, WTF::bind(&HandleTwoPhaseReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
+    m_readerTaskRunner->postTask(BLINK_FROM_HERE, WTF::bind(&HandleTwoPhaseReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
     m_reader = nullptr;
 }
 
@@ -298,4 +300,9 @@ void DataConsumerHandleTestUtil::HandleTwoPhaseReader::runOnFinishedReading(std:
     (*onFinishedReading)(std::move(result));
 }
 
+std::unique_ptr<WebTaskRunner> getCurrentTaskRunner()
+{
+    return Platform::current()->currentThread()->getWebTaskRunner()->clone();
+}
+
 } // namespace blink