Stop FetchDataLoaderTest from using [Web|Fetch]DataConsumerHandle.

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

Index: third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp
diff --git a/third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp b/third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp
index 3002f6555f62dd5a58bc588b2c242a69020a2a47..53dc27dcafc3dc0d97c42d8822c498ca863d42e8 100644
--- a/third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp
+++ b/third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp
@@ -5,7 +5,7 @@
 #include "modules/fetch/FetchDataLoader.h"
 
 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
-#include "modules/fetch/DataConsumerHandleTestUtil.h"
+#include "modules/fetch/BytesConsumerTestUtil.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <memory>
@@ -23,16 +23,9 @@ using ::testing::_;
 using ::testing::SaveArg;
 using ::testing::SetArgPointee;
 using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
-using MockFetchDataLoaderClient = DataConsumerHandleTestUtil::MockFetchDataLoaderClient;
-using MockHandle = DataConsumerHandleTestUtil::MockFetchDataConsumerHandle;
-using MockReader = DataConsumerHandleTestUtil::MockFetchDataConsumerReader;
-
-constexpr WebDataConsumerHandle::Result kOk = WebDataConsumerHandle::Ok;
-constexpr WebDataConsumerHandle::Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
-constexpr WebDataConsumerHandle::Result kShouldWait = WebDataConsumerHandle::ShouldWait;
-constexpr WebDataConsumerHandle::Result kDone = WebDataConsumerHandle::Done;
-constexpr WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
-constexpr FetchDataConsumerHandle::Reader::BlobSizePolicy kDisallowBlobWithInvalidSize = FetchDataConsumerHandle::Reader::DisallowBlobWithInvalidSize;
+using MockFetchDataLoaderClient = BytesConsumerTestUtil::MockFetchDataLoaderClient;
+using MockBytesConsumer = BytesConsumerTestUtil::MockBytesConsumer;
+using Result = BytesConsumer::Result;
 
 constexpr char kQuickBrownFox[] = "Quick brown fox";
 constexpr size_t kQuickBrownFoxLength = 15;
@@ -40,13 +33,9 @@ constexpr size_t kQuickBrownFoxLengthWithTerminatingNull = 16;
 
 TEST(FetchDataLoaderTest, LoadAsBlob)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
@@ -54,26 +43,25 @@ TEST(FetchDataLoaderTest, LoadAsBlob)
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::DisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengthWithTerminatingNull), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLengthWithTerminatingNull), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Done));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());

[hiroshige, 2016/09/30 08:16:48]

Memo: In this and the following tests, there are two patterns:

1. Previously there's EXPECT_CALL(destruct()), and this CL replaces it with
EXPECT_CALL(cancel()).
This is/was testing that BytesConsumer/FetchDataConsumerHandle's loading is
cancelled.

2. Previously there's not EXPECT_CALL(), and this CL adds EXPECT_CALL(cancel()).
This was testing that FetchDataConsumerHandle's loading was already
cancelled/completed and thus no further action was taken when FetchDataLoader is
cancelled.
However, BytesConsumer::cancel() is always called, and whether some actions are
taken for actually cancelling the loading depends on BytesConsumer (and
MockBytesConsumer lacks such logic).

I think this CL is OK, because from the sequence of EXPECT_CALL()s before
cancel() and EXPECT_CALL(cancel()), we can infer that getPublicState() would be
ReadableOrWaiting for Cases 1 and Closed/Errored for Cases 2.

     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
-    fetchDataLoader->cancel();
+    consumer->cancel();

[hiroshige, 2016/09/30 08:16:48]

I think |fetchDataLoader->cancel();| should be called here instead.

[yhirano, 2016/09/30 09:18:09]

Done.

     checkpoint.Call(4);
 
     ASSERT_TRUE(blobDataHandle);
@@ -83,65 +71,57 @@ TEST(FetchDataLoaderTest, LoadAsBlob)
 
 TEST(FetchDataLoaderTest, LoadAsBlobFailed)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| is adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::DisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengthWithTerminatingNull), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLengthWithTerminatingNull), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Error));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
-    fetchDataLoader->cancel();
+    consumer->cancel();
     checkpoint.Call(4);
 }
 
 TEST(FetchDataLoaderTest, LoadAsBlobCancel)
 {
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::DisallowBlobWithInvalidSize)).WillOnce(Return(nullptr));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     fetchDataLoader->cancel();
     checkpoint.Call(3);
@@ -155,11 +135,7 @@ TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType)
     RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(std::move(blobData), kQuickBrownFoxLengthWithTerminatingNull);
 
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
@@ -167,15 +143,14 @@ TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType)
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).WillOnce(Return(inputBlobDataHandle));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::DisallowBlobWithInvalidSize)).WillOnce(Return(inputBlobDataHandle));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
     EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     fetchDataLoader->cancel();
     checkpoint.Call(3);
@@ -194,11 +169,7 @@ TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithDifferentContent
     RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(std::move(blobData), kQuickBrownFoxLengthWithTerminatingNull);
 
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
@@ -206,15 +177,14 @@ TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithDifferentContent
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).WillOnce(Return(inputBlobDataHandle));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::DisallowBlobWithInvalidSize)).WillOnce(Return(inputBlobDataHandle));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
     EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     fetchDataLoader->cancel();
     checkpoint.Call(3);
@@ -227,13 +197,9 @@ TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithDifferentContent
 
 TEST(FetchDataLoaderTest, LoadAsArrayBuffer)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
@@ -241,23 +207,22 @@ TEST(FetchDataLoaderTest, LoadAsArrayBuffer)
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengthWithTerminatingNull), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLengthWithTerminatingNull), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Done));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).WillOnce(SaveArg<0>(&arrayBuffer));
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
     fetchDataLoader->cancel();
     checkpoint.Call(4);
@@ -269,36 +234,31 @@ TEST(FetchDataLoaderTest, LoadAsArrayBuffer)
 
 TEST(FetchDataLoaderTest, LoadAsArrayBufferFailed)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengthWithTerminatingNull), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLengthWithTerminatingNull), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Error));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
     fetchDataLoader->cancel();
     checkpoint.Call(4);
@@ -307,24 +267,22 @@ TEST(FetchDataLoaderTest, LoadAsArrayBufferFailed)
 TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel)
 {
     Checkpoint checkpoint;
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     fetchDataLoader->cancel();
     checkpoint.Call(3);
@@ -332,36 +290,31 @@ TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel)
 
 TEST(FetchDataLoaderTest, LoadAsString)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLength), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLength), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLength)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Done));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBrownFox)));
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
     fetchDataLoader->cancel();
     checkpoint.Call(4);
@@ -369,36 +322,34 @@ TEST(FetchDataLoaderTest, LoadAsString)
 
 TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
+    constexpr char kPattern[] = "Quick\0brown\0fox";
+    constexpr size_t kLength = sizeof(kPattern);
+
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
-    EXPECT_CALL(*reader, destruct());
-    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0brown\0fox", 16)));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(DoAll(SetArgPointee<0>(kPattern), SetArgPointee<1>(kLength), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(16)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Done));
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kPattern, kLength)));
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
     fetchDataLoader->cancel();
     checkpoint.Call(4);
@@ -406,36 +357,31 @@ TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes)
 
 TEST(FetchDataLoaderTest, LoadAsStringError)
 {
-    WebDataConsumerHandle::Client *client = nullptr;
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(ByMove(WTF::wrapUnique(reader)))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointee<3>(0), Return(kShouldWait)));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLength), Return(kOk)));
-    EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(kQuickBrownFox), SetArgPointee<1>(kQuickBrownFoxLength), Return(Result::Ok)));
+    EXPECT_CALL(*consumer, endRead(kQuickBrownFoxLength)).WillOnce(Return(Result::Ok));
+    EXPECT_CALL(*consumer, beginRead(_, _)).WillOnce(Return(Result::Error));
     EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
     EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     ASSERT_TRUE(client);
-    client->didGetReadable();
+    client->onStateChange();
     checkpoint.Call(3);
     fetchDataLoader->cancel();
     checkpoint.Call(4);
@@ -444,25 +390,22 @@ TEST(FetchDataLoaderTest, LoadAsStringError)
 TEST(FetchDataLoaderTest, LoadAsStringCancel)
 {
     Checkpoint checkpoint;
-
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumer::Client* client = nullptr;
+    MockBytesConsumer* consumer = MockBytesConsumer::create();
 
     FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
     MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
+    EXPECT_CALL(*consumer, setClient(_)).WillOnce(SaveArg<0>(&client));
+    EXPECT_CALL(*consumer, beginRead(_,  _)).WillOnce(DoAll(SetArgPointee<0>(nullptr), SetArgPointee<1>(0), Return(Result::ShouldWait)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*consumer, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     checkpoint.Call(1);
-    fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std::move(handle)), fetchDataLoaderClient);
+    fetchDataLoader->start(consumer, fetchDataLoaderClient);
     checkpoint.Call(2);
     fetchDataLoader->cancel();
     checkpoint.Call(3);