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

Unified Diff: third_party/WebKit/Source/modules/fetch/FetchBlobDataConsumerHandleTest.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/FetchBlobDataConsumerHandle.cpp ('k') | third_party/WebKit/Source/modules/fetch/FetchDataConsumerHandle.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

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

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

index 869a72738fe7476ffb443af95cb5fd1e4a9bb783..aa597e49bc16010fcbea0149894223ae584349ad 100644

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

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

@@ -18,9 +18,10 @@

#include "platform/testing/UnitTestHelpers.h"

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

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

-#include "wtf/OwnPtr.h"

#include "wtf/PassRefPtr.h"

+#include "wtf/PtrUtil.h"

#include "wtf/RefPtr.h"

+#include <memory>

#include <string.h>

namespace blink {

@@ -52,9 +53,9 @@ using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;

class MockLoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory {

public:

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

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

{

- return adoptPtr(createInternal(executionContext, client, threadableLoaderOptions, resourceLoaderOptions));

+ return wrapUnique(createInternal(executionContext, client, threadableLoaderOptions, resourceLoaderOptions));

}

MOCK_METHOD4(createInternal, ThreadableLoader*(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));

@@ -62,7 +63,7 @@ public:

PassRefPtr<BlobDataHandle> createBlobDataHandle(const char* s)

{

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

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

data->appendText(s, false);

auto size = data->length();

return BlobDataHandle::create(std::move(data), size);

@@ -87,7 +88,7 @@ public:

Document& document() { return m_dummyPageHolder->document(); }

private:

- OwnPtr<DummyPageHolder> m_dummyPageHolder;

+ std::unique_ptr<DummyPageHolder> m_dummyPageHolder;

};

TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)

@@ -99,7 +100,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)

ThreadableLoaderOptions options;

ResourceLoaderOptions resourceLoaderOptions;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

@@ -107,13 +108,13 @@ TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)

EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(

SaveArg<2>(&options),

SaveArg<3>(&resourceLoaderOptions),

- Return(loader.leakPtr())));

+ Return(loader.release())));

EXPECT_CALL(*loaderPtr, start(_)).WillOnce(SaveArg<0>(&request));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

testing::runPendingTasks();

@@ -144,19 +145,19 @@ TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenStopped)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.leakPtr()));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.release()));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

EXPECT_CALL(checkpoint, Call(3));

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

testing::runPendingTasks();

@@ -174,12 +175,12 @@ TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenDestinationDetached)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.leakPtr()));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.release()));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(checkpoint, Call(3));

@@ -187,9 +188,9 @@ TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenDestinationDetached)

EXPECT_CALL(checkpoint, Call(4));

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

testing::runPendingTasks();

size_t size = 0;

@@ -209,22 +210,22 @@ TEST_F(FetchBlobDataConsumerHandleTest, ReadTest)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

ThreadableLoaderClient* client = nullptr;

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.release())));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

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

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

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

@@ -238,7 +239,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, ReadTest)

checkpoint.Call(2);

client->didReceiveResponse(0, ResourceResponse(), std::move(src));

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

}

@@ -248,22 +249,22 @@ TEST_F(FetchBlobDataConsumerHandleTest, TwoPhaseReadTest)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

ThreadableLoaderClient* client = nullptr;

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.release())));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

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

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

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

@@ -277,7 +278,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, TwoPhaseReadTest)

checkpoint.Call(2);

client->didReceiveResponse(0, ResourceResponse(), std::move(src));

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

}

@@ -287,18 +288,18 @@ TEST_F(FetchBlobDataConsumerHandleTest, LoadErrorTest)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

ThreadableLoaderClient* client = nullptr;

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.release())));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

size_t size = 0;

@@ -308,7 +309,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, LoadErrorTest)

checkpoint.Call(2);

client->didFail(ResourceError());

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

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

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

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

}

@@ -317,22 +318,22 @@ TEST_F(FetchBlobDataConsumerHandleTest, BodyLoadErrorTest)

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

ThreadableLoaderClient* client = nullptr;

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

- EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));

+ EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.release())));

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<WebDataConsumerHandle> handle

+ std::unique_ptr<WebDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

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

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

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

@@ -344,7 +345,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, BodyLoadErrorTest)

checkpoint.Call(2);

client->didReceiveResponse(0, ResourceResponse(), std::move(src));

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

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

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

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

}

@@ -353,7 +354,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, DrainAsBlobDataHandle)

auto factory = new StrictMock<MockLoaderFactory>;

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<FetchDataConsumerHandle> handle

+ std::unique_ptr<FetchDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

size_t size = 0;

@@ -368,7 +369,7 @@ TEST_F(FetchBlobDataConsumerHandleTest, DrainAsFormData)

auto factory = new StrictMock<MockLoaderFactory>;

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<FetchDataConsumerHandle> handle

+ std::unique_ptr<FetchDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

RefPtr<EncodedFormData> formData = handle->obtainReader(nullptr)->drainAsFormData();

@@ -389,9 +390,9 @@ TEST_F(FetchBlobDataConsumerHandleTest, ZeroByteReadDoesNotAffectDraining)

auto factory = new StrictMock<MockLoaderFactory>;

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<FetchDataConsumerHandle> handle

+ std::unique_ptr<FetchDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

size_t readSize;

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

@@ -403,9 +404,9 @@ TEST_F(FetchBlobDataConsumerHandleTest, OneByteReadAffectsDraining)

auto factory = new StrictMock<MockLoaderFactory>;

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<FetchDataConsumerHandle> handle

+ std::unique_ptr<FetchDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

size_t readSize;

char c;

@@ -418,9 +419,9 @@ TEST_F(FetchBlobDataConsumerHandleTest, BeginReadAffectsDraining)

auto factory = new StrictMock<MockLoaderFactory>;

RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");

- OwnPtr<FetchDataConsumerHandle> handle

+ std::unique_ptr<FetchDataConsumerHandle> handle

= FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);

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

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

const void* buffer;

size_t available;