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

third_party/WebKit/Source/modules/fetch/CompositeDataConsumerHandleTest.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/CompositeDataConsumerHandle.h"
 
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/Handle.h"
@@ skipping 28 matching lines @@
     using Flags = WebDataConsumerHandle::Flags;
     MOCK_METHOD4(read, Result(void*, size_t, Flags, size_t*));
     MOCK_METHOD3(beginRead, Result(const void**, Flags, size_t*));
     MOCK_METHOD1(endRead, Result(size_t));
 };
 
 class MockHandle : public WebDataConsumerHandle {
 public:
     static std::unique_ptr<StrictMock<MockHandle>> create() { return wrapUnique(new StrictMock<MockHandle>); }
 
-    MOCK_METHOD1(obtainReader, std::unique_ptr<Reader>(Client*));
+    MOCK_METHOD1(obtainReaderMock, std::unique_ptr<Reader>(Client*));
+    std::unique_ptr<Reader> obtainReader(Client* client, std::unique_ptr<WebTaskRunner>) override
+    {
+        return obtainReaderMock(client);
+    }
 
 private:
     const char* debugName() const override { return "MockHandle in CompositeDataConsumerHandleTest"; }
 };
 
 class ThreadingRegistrationTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
 
         postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
         postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingRegistrationTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
     void obtainReader()
     {
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
         postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
 
@@ skipping 19 matching lines @@
     ThreadingRegistrationDeleteHandleTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
         postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
         m_handle = nullptr;
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
@@ skipping 20 matching lines @@
     ThreadingRegistrationDeleteReaderTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
         postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
@@ skipping 21 matching lines @@
     ThreadingUpdatingReaderWhileUpdatingTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
         postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
         m_updateEvent->wait();
     }
 
     void update()
     {
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::reobtainReader, wrapPassRefPtr(this)));
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
         m_updateEvent->signal();
     }
 
     void reobtainReader()
     {
         m_reader = nullptr;
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
     std::unique_ptr<WaitableEvent> m_updateEvent;
 };
 
 class ThreadingRegistrationUpdateTwiceAtOneTimeTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationUpdateTwiceAtOneTimeTest;
@@ skipping 13 matching lines @@
     ThreadingRegistrationUpdateTwiceAtOneTimeTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
-        m_reader = m_handle->obtainReader(&m_client);
+        m_reader = m_handle->obtainReader(&m_client, m_context->getReadingThreadTaskRunner()->clone());
         postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
         // Stalls this thread while updating handles.
         m_updateEvent->wait();
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater->update(DataConsumerHandle::create("handle3", m_context));
         m_updateEvent->signal();
         m_updater.clear();
@@ skipping 15 matching lines @@
 
     std::unique_ptr<MockHandle> handle1 = MockHandle::create();
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
 
     // They will be adopted by |obtainReader|.
     MockReader* reader1 = MockReader::create().release();
     MockReader* reader2 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReader(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
+    EXPECT_CALL(*handle1, obtainReaderMock(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, read(buffer, sizeof(buffer), kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*handle2, obtainReader(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
+    EXPECT_CALL(*handle2, obtainReaderMock(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*reader2, read(buffer, sizeof(buffer), kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(4));
 
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
-    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(&client);
+    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(&client, getCurrentTaskRunner());
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(2);
     updater->update(std::move(handle2));
     checkpoint.Call(3);
     EXPECT_EQ(kOk, reader->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(4);
 }
 
 TEST(CompositeDataConsumerHandleTest, TwoPhaseRead)
 {
     const void* p = nullptr;
     size_t size = 0;
     Checkpoint checkpoint;
 
     std::unique_ptr<MockHandle> handle1 = MockHandle::create();
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
 
     // They are adopted by |obtainReader|.
     MockReader* reader1 = MockReader::create().release();
     MockReader* reader2 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
+    EXPECT_CALL(*handle1, obtainReaderMock(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*reader1, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(3));
-    EXPECT_CALL(*handle2, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
+    EXPECT_CALL(*handle2, obtainReaderMock(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*reader2, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(5));
     EXPECT_CALL(*reader2, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(6));
 
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
-    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr, getCurrentTaskRunner());
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(2);
     EXPECT_EQ(kOk, reader->endRead(0));
     checkpoint.Call(3);
     updater->update(std::move(handle2));
     checkpoint.Call(4);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(5);
     EXPECT_EQ(kOk, reader->endRead(0));
@@ skipping 10 matching lines @@
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
     std::unique_ptr<MockHandle> handle3 = MockHandle::create();
 
     // They are adopted by |obtainReader|.
     MockReader* reader1 = MockReader::create().release();
     MockReader* reader2 = MockReader::create().release();
     MockReader* reader3 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
+    EXPECT_CALL(*handle1, obtainReaderMock(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*reader1, endRead(0)).WillOnce(Return(kOk));
-    EXPECT_CALL(*handle2, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
+    EXPECT_CALL(*handle2, obtainReaderMock(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*reader2, beginRead(&p, kNone, &size)).WillOnce(Return(kShouldWait));
     EXPECT_CALL(checkpoint, Call(5));
-    EXPECT_CALL(*handle3, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader3))));
+    EXPECT_CALL(*handle3, obtainReaderMock(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader3))));
     EXPECT_CALL(checkpoint, Call(6));
     EXPECT_CALL(*reader3, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(7));
     EXPECT_CALL(*reader3, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(8));
 
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
-    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr, getCurrentTaskRunner());
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(2);
     updater->update(std::move(handle2));
     checkpoint.Call(3);
     EXPECT_EQ(kOk, reader->endRead(0));
     checkpoint.Call(4);
     EXPECT_EQ(kShouldWait, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(5);
     updater->update(std::move(handle3));
@@ skipping 79 matching lines @@
 {
     RefPtr<DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest> test = DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest::create();
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     // Test this function doesn't crash.
     test->run(CompositeDataConsumerHandle::create(createDoneDataConsumerHandle(), &updater));
 }
 
 } // namespace
 
 } // namespace blink