[2a] Implement FetchDataLoader

Source/modules/fetch/FetchDataLoaderTest.cpp

Index: Source/modules/fetch/FetchDataLoaderTest.cpp
diff --git a/Source/modules/fetch/FetchDataLoaderTest.cpp b/Source/modules/fetch/FetchDataLoaderTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c7a55378df87f11be73199f8a160ac29ad5546d4
--- /dev/null
+++ b/Source/modules/fetch/FetchDataLoaderTest.cpp
@@ -0,0 +1,467 @@
+// 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 "config.h"
+#include "modules/fetch/FetchDataLoader.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace blink {
+
+namespace {
+
+using ::testing::InSequence;
+using ::testing::Return;
+using ::testing::DoAll;
+using ::testing::StrictMock;
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::SetArgPointee;
+using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
+
+const WebDataConsumerHandle::Result kOk = WebDataConsumerHandle::Ok;
+const WebDataConsumerHandle::Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
+const WebDataConsumerHandle::Result kDone = WebDataConsumerHandle::Done;
+const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
+
+class MockReader : public FetchDataConsumerHandle::Reader {
+public:
+    static PassOwnPtr<StrictMock<MockReader>> create() { return adoptPtr(new StrictMock<MockReader>); }
+
+    using Result = WebDataConsumerHandle::Result;
+    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));
+    MOCK_METHOD0(drainAsBlobDataHandle, PassRefPtr<BlobDataHandle>());
+
+    ~MockReader()

[yhirano, 2015/06/19 06:19:30]

+ override

[hiroshige, 2015/06/19 07:27:56]

Done.

+    {
+        destruct();
+    }
+    MOCK_METHOD0(destruct, void());
+};
+
+class MockHandle : public FetchDataConsumerHandle {
+public:
+    static PassOwnPtr<StrictMock<MockHandle>> create() { return adoptPtr(new StrictMock<MockHandle>); }
+
+    MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
+};
+
+class MockFetchDataLoaderClient : public GarbageCollectedFinalized<MockFetchDataLoaderClient>, public FetchDataLoader::Client {
+    USING_GARBAGE_COLLECTED_MIXIN(MockFetchDataLoaderClient);
+public:
+    static StrictMock<MockFetchDataLoaderClient>* create() { return new StrictMock<MockFetchDataLoaderClient>; }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        FetchDataLoader::Client::trace(visitor);
+    }
+
+    MOCK_METHOD1(didFetchDataLoadedBlobHandleMock, void(RefPtr<BlobDataHandle>));
+    MOCK_METHOD1(didFetchDataLoadedArrayBufferMock, void(RefPtr<DOMArrayBuffer>));
+    MOCK_METHOD1(didFetchDataLoadedString, void(const String&));
+    MOCK_METHOD0(didFetchDataLoadFailed, void());
+
+    // In mock methods we use RefPtr<> rather than PassRefPtr<>.
+    void didFetchDataLoadedArrayBuffer(PassRefPtr<DOMArrayBuffer> arrayBuffer) override
+    {
+        didFetchDataLoadedArrayBufferMock(arrayBuffer);
+    }
+    void didFetchDataLoadedBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle) override
+    {
+        didFetchDataLoadedBlobHandleMock(blobDataHandle);
+    }
+};
+
+TEST(FetchDataLoaderTest, LoadAsBlob)
+{
+    char buffer[16] = "Quick brown fox";

[yhirano, 2015/06/19 06:19:30]

+const?

[yhirano, 2015/06/19 06:19:30]

[optional] It would be good to decrease the magic number "16" and "15".

You can use strlen, or you can define
const char kQuickBrownFox[] = "Quick brown for";
and
const size_t kQuickBrownFoxLength = WTF_ARRAY_LENGTH(kQuickBrownFox) - 1;
possibly globally.

[hiroshige, 2015/06/19 07:27:56]

I introduced kQuickBrownFox, kQuickBrownFoxLength,
kQuickBrownFoxLengthWithTerminatingNull to remove duplication but prefer to keep
magic numbers to avoid logics (strlen or WTF_ARRAY_LENGTH) in the tests.

[hiroshige, 2015/06/19 07:27:57]

Done.

+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+    RefPtr<BlobDataHandle> blobDataHandle;
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(*reader, drainAsBlobDataHandle()).WillOnce(Return(nullptr));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(16), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(16)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+
+    ASSERT_TRUE(blobDataHandle);
+    EXPECT_EQ(16ULL, blobDataHandle->size());
+    EXPECT_EQ(String("text/test"), blobDataHandle->type());
+}
+
+TEST(FetchDataLoaderTest, LoadAsBlobFailed)
+{
+    char buffer[16] = "Quick brown fox";
+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(*reader, drainAsBlobDataHandle()).WillOnce(Return(nullptr));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(16), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(16)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+}
+
+TEST(FetchDataLoaderTest, LoadAsBlobCancel)
+{
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get()));
+    EXPECT_CALL(*reader, drainAsBlobDataHandle()).WillOnce(Return(nullptr));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(checkpoint, Call(3));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    fetchDataLoader->cancel();
+    checkpoint.Call(3);
+}
+
+TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType)
+{
+    OwnPtr<BlobData> blobData = BlobData::create();
+    blobData->appendBytes("Quick brown fox", 16);
+    blobData->setContentType("text/test");
+    RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(blobData.release(), 16);
+
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+    RefPtr<BlobDataHandle> blobDataHandle;
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get()));
+    EXPECT_CALL(*reader, drainAsBlobDataHandle()).WillOnce(Return(inputBlobDataHandle));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(checkpoint, Call(3));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    fetchDataLoader->cancel();
+    checkpoint.Call(3);
+
+    ASSERT_TRUE(blobDataHandle);
+    EXPECT_EQ(inputBlobDataHandle, blobDataHandle);
+    EXPECT_EQ(16ULL, blobDataHandle->size());
+    EXPECT_EQ(String("text/test"), blobDataHandle->type());
+}
+
+TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithDifferentContentType)
+{
+    OwnPtr<BlobData> blobData = BlobData::create();
+    blobData->appendBytes("Quick brown fox", 16);
+    blobData->setContentType("text/different");
+    RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(blobData.release(), 16);
+
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle("text/test");
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+    RefPtr<BlobDataHandle> blobDataHandle;
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get()));
+    EXPECT_CALL(*reader, drainAsBlobDataHandle()).WillOnce(Return(inputBlobDataHandle));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0>(&blobDataHandle));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(checkpoint, Call(3));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    fetchDataLoader->cancel();
+    checkpoint.Call(3);
+
+    ASSERT_TRUE(blobDataHandle);
+    EXPECT_NE(inputBlobDataHandle, blobDataHandle);
+    EXPECT_EQ(16ULL, blobDataHandle->size());
+    EXPECT_EQ(String("text/test"), blobDataHandle->type());
+}
+
+TEST(FetchDataLoaderTest, LoadAsArrayBuffer)
+{
+    char buffer[16] = "Quick brown fox";
+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+    RefPtr<DOMArrayBuffer> arrayBuffer;
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(16), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(16)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).WillOnce(SaveArg<0>(&arrayBuffer));
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+
+    ASSERT_TRUE(arrayBuffer);
+    ASSERT_EQ(16U, arrayBuffer->byteLength());
+    EXPECT_STREQ("Quick brown fox", static_cast<const char*>(arrayBuffer->data()));
+}
+
+TEST(FetchDataLoaderTest, LoadAsArrayBufferFailed)
+{
+    char buffer[16] = "Quick brown fox";
+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(16), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(16)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+}
+
+TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel)
+{
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get()));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(checkpoint, Call(3));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    fetchDataLoader->cancel();
+    checkpoint.Call(3);
+}
+
+TEST(FetchDataLoaderTest, LoadAsString)
+{
+    char buffer[16] = "Quick brown fox";
+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(15), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(15)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick brown fox")));
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+}
+
+TEST(FetchDataLoaderTest, LoadAsStringError)
+{
+    char buffer[16] = "Quick brown fox";
+    WebDataConsumerHandle::Client *client = nullptr;
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&client), Return(reader.get())));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0>(static_cast<const void*>(buffer)), SetArgPointee<2>(15), Return(kOk)));
+    EXPECT_CALL(*reader, endRead(15)).WillOnce(Return(kOk));
+    EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedError));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
+    EXPECT_CALL(checkpoint, Call(3));
+    EXPECT_CALL(checkpoint, Call(4));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    ASSERT_TRUE(client);
+    client->didGetReadable();
+    checkpoint.Call(3);
+    fetchDataLoader->cancel();
+    checkpoint.Call(4);
+}
+
+TEST(FetchDataLoaderTest, LoadAsStringCancel)
+{
+    Checkpoint checkpoint;
+
+    OwnPtr<MockHandle> handle = MockHandle::create();
+    OwnPtr<MockReader> reader = MockReader::create();
+    FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
+    MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient::create();
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get()));
+    EXPECT_CALL(checkpoint, Call(2));
+    EXPECT_CALL(*reader, destruct());
+    EXPECT_CALL(checkpoint, Call(3));
+
+    // |reader| is adopted by |obtainReader|.
+    ASSERT_TRUE(reader.leakPtr());
+
+    checkpoint.Call(1);
+    fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
+    checkpoint.Call(2);
+    fetchDataLoader->cancel();
+    checkpoint.Call(3);
+}
+
+} // namespace
+
+} // namespace blink