third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp - Issue 2376193004: Stop FetchDataLoaderTest from using [Web|Fetch]DataConsumerHandle.

Unified Diff: third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp

Issue 2376193004: Stop FetchDataLoaderTest from using [Web|Fetch]DataConsumerHandle. (Closed)

Patch Set: fix Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h ('k') | third_party/WebKit/Source/modules/fetch/FormDataBytesConsumerTest.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

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..3250755b83d937f86560fa886ac86628eceaacb6 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,24 +43,23 @@ 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());

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);

@@ -83,37 +71,32 @@ 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();

checkpoint.Call(4);

@@ -122,26 +105,23 @@ TEST(FetchDataLoaderTest, LoadAsBlobFailed)

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);