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..3b72a437a07bc2091f882071b1da9e20e3d96264 100644
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp
@@ -92,9 +92,12 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::add(const Command& co
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::attachReader(WebDataConsumerHandle::Client* client)
 {
     MutexLocker locker(m_mutex);
-    DCHECK(!m_readerThread);
+    DCHECK(!m_readerTaskRunner);
     DCHECK(!m_client);
-    m_readerThread = Platform::current()->currentThread();
+    if (client)
+        m_readerTaskRunner = client->getTaskRunner()->clone();
+    else
+        m_readerTaskRunner = Platform::current()->currentThread()->getWebTaskRunner()->clone();
     m_client = client;
 
     if (m_client && !(isEmpty() && m_result == ShouldWait))
@@ -104,8 +107,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 +118,7 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::detachHandle()
 {
     MutexLocker locker(m_mutex);
     m_isHandleAttached = false;
-    if (!m_readerThread)
+    if (!m_readerTaskRunner)
         m_detached->signal();
 }
 
@@ -163,7 +166,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 +197,14 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Context::notify()
 {
     if (!m_client)
         return;
-    DCHECK(m_readerThread);
-    m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&Context::notifyInternal, wrapPassRefPtr(this)));
+    m_client->getTaskRunner()->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;
         }
@@ -231,8 +233,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_onFinishedReading(std::move(onFinishedReading))
 {
 }
@@ -252,10 +255,15 @@ 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;
 }
 
+WebTaskRunner* DataConsumerHandleTestUtil::HandleReader::getTaskRunner()
+{
+    return m_readerTaskRunner.get();
+}
+
 void DataConsumerHandleTestUtil::HandleReader::runOnFinishedReading(std::unique_ptr<HandleReadResult> result)
 {
     DCHECK(m_onFinishedReading);
@@ -263,8 +271,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_onFinishedReading(std::move(onFinishedReading))
 {
 }
@@ -287,10 +296,15 @@ 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;
 }
 
+WebTaskRunner* DataConsumerHandleTestUtil::HandleTwoPhaseReader::getTaskRunner()
+{
+    return m_readerTaskRunner.get();
+}
+
 void DataConsumerHandleTestUtil::HandleTwoPhaseReader::runOnFinishedReading(std::unique_ptr<HandleReadResult> result)
 {
     DCHECK(m_onFinishedReading);