third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp - Issue 2050123002: Remove OwnPtr from Blink.

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

Issue 2050123002: Remove OwnPtr from Blink. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: First attempt to land. Created 4 years, 6 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

Download patch

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

Index: third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp

diff --git a/third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp b/third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp

index f4432a687b07b03e2c29394b811e611c69ead6f9..43262d022f9727b0bd8e4b2b10d9563a5642cbae 100644

--- a/third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp

+++ b/third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.cpp

@@ -15,13 +15,12 @@

#include "platform/weborigin/KURL.h"

#include "testing/gmock/include/gmock/gmock.h"

#include "testing/gtest/include/gtest/gtest.h"

-#include "wtf/OwnPtr.h"

-#include "wtf/PassOwnPtr.h"

#include "wtf/PassRefPtr.h"

#include "wtf/RefPtr.h"

#include "wtf/Vector.h"

#include "wtf/text/TextEncoding.h"

#include "wtf/text/WTFString.h"

+#include <memory>

#include <string.h>

namespace blink {

@@ -50,14 +49,14 @@ String toString(const Vector<char>& data)

class LoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory {

public:

- explicit LoaderFactory(PassOwnPtr<WebDataConsumerHandle> handle)

+ explicit LoaderFactory(std::unique_ptr<WebDataConsumerHandle> handle)

: m_client(nullptr)

, m_handle(std::move(handle)) {}

- PassOwnPtr<ThreadableLoader> create(ExecutionContext&, ThreadableLoaderClient* client, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override

+ std::unique_ptr<ThreadableLoader> create(ExecutionContext&, ThreadableLoaderClient* client, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override

{

m_client = client;

- OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();

+ std::unique_ptr<MockThreadableLoader> loader = MockThreadableLoader::create();

EXPECT_CALL(*loader, start(_)).WillOnce(InvokeWithoutArgs(this, &LoaderFactory::handleDidReceiveResponse));

EXPECT_CALL(*loader, cancel()).Times(1);

return std::move(loader);

@@ -70,7 +69,7 @@ private:

}

ThreadableLoaderClient* m_client;

- OwnPtr<WebDataConsumerHandle> m_handle;

+ std::unique_ptr<WebDataConsumerHandle> m_handle;

};

class FetchFormDataConsumerHandleTest : public ::testing::Test {

@@ -80,7 +79,7 @@ public:

protected:

Document* getDocument() { return &m_page->document(); }

- OwnPtr<DummyPageHolder> m_page;

+ std::unique_ptr<DummyPageHolder> m_page;

};

PassRefPtr<EncodedFormData> complexFormData()

@@ -90,7 +89,7 @@ PassRefPtr<EncodedFormData> complexFormData()

data->appendData("foo", 3);

data->appendFileRange("/foo/bar/baz", 3, 4, 5);

data->appendFileSystemURLRange(KURL(KURL(), "file:///foo/bar/baz"), 6, 7, 8);

- OwnPtr<BlobData> blobData = BlobData::create();

+ std::unique_ptr<BlobData> blobData = BlobData::create();

blobData->appendText("hello", false);

auto size = blobData->length();

RefPtr<BlobDataHandle> blobDataHandle = BlobDataHandle::create(std::move(blobData), size);

@@ -132,18 +131,18 @@ void verifyComplexFormData(EncodedFormData* data)

TEST_F(FetchFormDataConsumerHandleTest, ReadFromString)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

HandleReaderRunner<HandleReader> runner(std::move(handle));

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("hello, world", toString(r->data()));

}

TEST_F(FetchFormDataConsumerHandleTest, TwoPhaseReadFromString)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

HandleReaderRunner<HandleTwoPhaseReader> runner(std::move(handle));

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("hello, world", toString(r->data()));

}

@@ -151,9 +150,9 @@ TEST_F(FetchFormDataConsumerHandleTest, TwoPhaseReadFromString)

TEST_F(FetchFormDataConsumerHandleTest, ReadFromStringNonLatin)

{

UChar cs[] = {0x3042, 0};

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String(cs));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String(cs));

HandleReaderRunner<HandleReader> runner(std::move(handle));

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("\xe3\x81\x82", toString(r->data()));

}

@@ -162,9 +161,9 @@ TEST_F(FetchFormDataConsumerHandleTest, ReadFromArrayBuffer)

{

const unsigned char data[] = { 0x21, 0xfe, 0x00, 0x00, 0xff, 0xa3, 0x42, 0x30, 0x42, 0x99, 0x88 };

DOMArrayBuffer* buffer = DOMArrayBuffer::create(data, WTF_ARRAY_LENGTH(data));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(buffer);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(buffer);

HandleReaderRunner<HandleReader> runner(std::move(handle));

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

Vector<char> expected;

expected.append(data, WTF_ARRAY_LENGTH(data));

@@ -176,9 +175,9 @@ TEST_F(FetchFormDataConsumerHandleTest, ReadFromArrayBufferView)

const unsigned char data[] = { 0x21, 0xfe, 0x00, 0x00, 0xff, 0xa3, 0x42, 0x30, 0x42, 0x99, 0x88 };

const size_t offset = 1, size = 4;

DOMArrayBuffer* buffer = DOMArrayBuffer::create(data, WTF_ARRAY_LENGTH(data));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMUint8Array::create(buffer, offset, size));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMUint8Array::create(buffer, offset, size));

HandleReaderRunner<HandleReader> runner(std::move(handle));

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

Vector<char> expected;

expected.append(data + offset, size);

@@ -191,10 +190,10 @@ TEST_F(FetchFormDataConsumerHandleTest, ReadFromSimplFormData)

data->appendData("foo", 3);

data->appendData("hoge", 4);

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), data);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), data);

HandleReaderRunner<HandleReader> runner(std::move(handle));

testing::runPendingTasks();

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("foohoge", toString(r->data()));

}

@@ -202,17 +201,17 @@ TEST_F(FetchFormDataConsumerHandleTest, ReadFromSimplFormData)

TEST_F(FetchFormDataConsumerHandleTest, ReadFromComplexFormData)

{

RefPtr<EncodedFormData> data = complexFormData();

- OwnPtr<ReplayingHandle> src = ReplayingHandle::create();

+ std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();

src->add(Command(Command::Data, "bar"));

src->add(Command(Command::Done));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), data, new LoaderFactory(std::move(src)));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), data, new LoaderFactory(std::move(src)));

char c;

size_t readSize;

EXPECT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(&c, 1, kNone, &readSize));

HandleReaderRunner<HandleReader> runner(std::move(handle));

testing::runPendingTasks();

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("bar", toString(r->data()));

}

@@ -220,25 +219,25 @@ TEST_F(FetchFormDataConsumerHandleTest, ReadFromComplexFormData)

TEST_F(FetchFormDataConsumerHandleTest, TwoPhaseReadFromComplexFormData)

{

RefPtr<EncodedFormData> data = complexFormData();

- OwnPtr<ReplayingHandle> src = ReplayingHandle::create();

+ std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();

src->add(Command(Command::Data, "bar"));

src->add(Command(Command::Done));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), data, new LoaderFactory(std::move(src)));

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), data, new LoaderFactory(std::move(src)));

char c;

size_t readSize;

EXPECT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(&c, 1, kNone, &readSize));

HandleReaderRunner<HandleTwoPhaseReader> runner(std::move(handle));

testing::runPendingTasks();

- OwnPtr<HandleReadResult> r = runner.wait();

+ std::unique_ptr<HandleReadResult> r = runner.wait();

EXPECT_EQ(kDone, r->result());

EXPECT_EQ("bar", toString(r->data()));

}

TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromString)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();

ASSERT_TRUE(blobDataHandle);

@@ -252,8 +251,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromString)

TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromArrayBuffer)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();

ASSERT_TRUE(blobDataHandle);

@@ -272,8 +271,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromSimpleFormData)

data->append("name2", "value2");

RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData();

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();

ASSERT_TRUE(blobDataHandle);

@@ -289,8 +288,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromComplexFormData

{

RefPtr<EncodedFormData> inputFormData = complexFormData();

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();

ASSERT_TRUE(blobDataHandle);

@@ -302,8 +301,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromComplexFormData

TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromString)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<EncodedFormData> formData = reader->drainAsFormData();

ASSERT_TRUE(formData);

EXPECT_TRUE(formData->isSafeToSendToAnotherThread());

@@ -317,8 +316,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromString)

TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromArrayBuffer)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<EncodedFormData> formData = reader->drainAsFormData();

ASSERT_TRUE(formData);

EXPECT_TRUE(formData->isSafeToSendToAnotherThread());

@@ -332,8 +331,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromSimpleFormData)

data->append("name2", "value2");

RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData();

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<EncodedFormData> outputFormData = reader->drainAsFormData();

ASSERT_TRUE(outputFormData);

EXPECT_TRUE(outputFormData->isSafeToSendToAnotherThread());

@@ -345,8 +344,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromComplexFormData)

{

RefPtr<EncodedFormData> inputFormData = complexFormData();

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

RefPtr<EncodedFormData> outputFormData = reader->drainAsFormData();

ASSERT_TRUE(outputFormData);

EXPECT_TRUE(outputFormData->isSafeToSendToAnotherThread());

@@ -356,8 +355,8 @@ TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromComplexFormData)

TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDraining)

{

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

size_t readSize;

EXPECT_EQ(kOk, reader->read(nullptr, 0, kNone, &readSize));

RefPtr<EncodedFormData> formData = reader->drainAsFormData();

@@ -369,8 +368,8 @@ TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDraining)

TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDraining)

{

char c;

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

size_t readSize;

EXPECT_EQ(kOk, reader->read(&c, 1, kNone, &readSize));

EXPECT_EQ(1u, readSize);

@@ -381,8 +380,8 @@ TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDraining)

TEST_F(FetchFormDataConsumerHandleTest, BeginReadAffectsDraining)

{

const void* buffer = nullptr;

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

size_t available;

EXPECT_EQ(kOk, reader->beginRead(&buffer, kNone, &available));

ASSERT_TRUE(buffer);

@@ -394,11 +393,11 @@ TEST_F(FetchFormDataConsumerHandleTest, BeginReadAffectsDraining)

TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDrainingForComplexFormData)

{

- OwnPtr<ReplayingHandle> src = ReplayingHandle::create();

+ std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();

src->add(Command(Command::Data, "bar"));

src->add(Command(Command::Done));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

size_t readSize;

EXPECT_EQ(kShouldWait, reader->read(nullptr, 0, kNone, &readSize));

testing::runPendingTasks();

@@ -411,11 +410,11 @@ TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDrainingForComp

TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDrainingForComplexFormData)

{

- OwnPtr<ReplayingHandle> src = ReplayingHandle::create();

+ std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();

src->add(Command(Command::Data, "bar"));

src->add(Command(Command::Done));

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

char c;

size_t readSize;

EXPECT_EQ(kShouldWait, reader->read(&c, 1, kNone, &readSize));

@@ -428,12 +427,12 @@ TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDrainingForComplexForm

TEST_F(FetchFormDataConsumerHandleTest, BeginReadAffectsDrainingForComplexFormData)

{

- OwnPtr<ReplayingHandle> src = ReplayingHandle::create();

+ std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();

src->add(Command(Command::Data, "bar"));

src->add(Command(Command::Done));

const void* buffer = nullptr;

- OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

- OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

+ std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));

+ std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);

size_t available;

EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));

testing::runPendingTasks();