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

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

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

Patch Set: 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 aa597e49bc16010fcbea0149894223ae584349ad..869a72738fe7476ffb443af95cb5fd1e4a9bb783 100644

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

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

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

#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 {

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

class MockLoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory {

public:

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

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

{

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

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

}

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

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

PassRefPtr<BlobDataHandle> createBlobDataHandle(const char* s)

{

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

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

data->appendText(s, false);

auto size = data->length();

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

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

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

private:

- std::unique_ptr<DummyPageHolder> m_dummyPageHolder;

+ OwnPtr<DummyPageHolder> m_dummyPageHolder;

};

TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)

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

ThreadableLoaderOptions options;

ResourceLoaderOptions resourceLoaderOptions;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

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

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

SaveArg<2>(&options),

SaveArg<3>(&resourceLoaderOptions),

- Return(loader.release())));

+ Return(loader.leakPtr())));

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

testing::runPendingTasks();

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

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

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

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

testing::runPendingTasks();

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

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

MockThreadableLoader* loaderPtr = loader.get();

InSequence s;

EXPECT_CALL(checkpoint, Call(1));

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

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

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(checkpoint, Call(3));

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

EXPECT_CALL(checkpoint, Call(4));

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

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

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

testing::runPendingTasks();

size_t size = 0;

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

+ OwnPtr<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.release())));

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

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

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

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

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

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

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

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

checkpoint.Call(2);

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

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

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

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

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

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

}

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

+ OwnPtr<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.release())));

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

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

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

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

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

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

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

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

checkpoint.Call(2);

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

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

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

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

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

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

}

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

+ OwnPtr<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.release())));

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

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

size_t size = 0;

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

checkpoint.Call(2);

client->didFail(ResourceError());

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

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

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

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

}

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

auto factory = new StrictMock<MockLoaderFactory>;

Checkpoint checkpoint;

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

+ OwnPtr<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.release())));

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

EXPECT_CALL(*loaderPtr, start(_));

EXPECT_CALL(checkpoint, Call(2));

EXPECT_CALL(*loaderPtr, cancel());

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

- std::unique_ptr<WebDataConsumerHandle> handle

+ OwnPtr<WebDataConsumerHandle> handle

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

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

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

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

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

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

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

checkpoint.Call(2);

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

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

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

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

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

}

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

auto factory = new StrictMock<MockLoaderFactory>;

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

- std::unique_ptr<FetchDataConsumerHandle> handle

+ OwnPtr<FetchDataConsumerHandle> handle

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

size_t size = 0;

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

auto factory = new StrictMock<MockLoaderFactory>;

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

- std::unique_ptr<FetchDataConsumerHandle> handle

+ OwnPtr<FetchDataConsumerHandle> handle

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

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

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

auto factory = new StrictMock<MockLoaderFactory>;

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

- std::unique_ptr<FetchDataConsumerHandle> handle

+ OwnPtr<FetchDataConsumerHandle> handle

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

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

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

size_t readSize;

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

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

auto factory = new StrictMock<MockLoaderFactory>;

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

- std::unique_ptr<FetchDataConsumerHandle> handle

+ OwnPtr<FetchDataConsumerHandle> handle

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

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

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

size_t readSize;

char c;

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

auto factory = new StrictMock<MockLoaderFactory>;

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

- std::unique_ptr<FetchDataConsumerHandle> handle

+ OwnPtr<FetchDataConsumerHandle> handle

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

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

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

const void* buffer;

size_t available;