Return unique_ptr<WebDataConsumerHandle::Reader> directly from obtainReader

third_party/WebKit/Source/modules/fetch/CompositeDataConsumerHandleTest.cpp

 // 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 "modules/fetch/CompositeDataConsumerHandle.h"
 
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Locker.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
+using ::testing::ByMove;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::StrictMock;
 using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
 
 const WebDataConsumerHandle::Result kShouldWait = WebDataConsumerHandle::ShouldWait;
 const WebDataConsumerHandle::Result kOk = WebDataConsumerHandle::Ok;
 const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
 
 class MockReader : public WebDataConsumerHandle::Reader {
 public:
     static std::unique_ptr<StrictMock<MockReader>> create() { return wrapUnique(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));
 };
 
 class MockHandle : public WebDataConsumerHandle {
 public:
     static std::unique_ptr<StrictMock<MockHandle>> create() { return wrapUnique(new StrictMock<MockHandle>); }
 
-    MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
+    MOCK_METHOD1(obtainReader, std::unique_ptr<Reader>(Client*));
 
 private:
     const char* debugName() const override { return "MockHandle in CompositeDataConsumerHandleTest"; }
 };
 
 class ThreadingRegistrationTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
@@ skipping 213 matching lines @@
 
 TEST(CompositeDataConsumerHandleTest, Read)
 {
     char buffer[20];
     size_t size = 0;
     DataConsumerHandleTestUtil::NoopClient client;
     Checkpoint checkpoint;
 
     std::unique_ptr<MockHandle> handle1 = MockHandle::create();
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
-    std::unique_ptr<MockReader> reader1 = MockReader::create();
-    std::unique_ptr<MockReader> reader2 = MockReader::create();
+
+    // They will be adopted by |obtainReader|.
+    MockReader* reader1 = MockReader::create().release();
+    MockReader* reader2 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReaderInternal(&client)).WillOnce(Return(reader1.get()));
+    EXPECT_CALL(*handle1, obtainReader(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, read(buffer, sizeof(buffer), kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*handle2, obtainReaderInternal(&client)).WillOnce(Return(reader2.get()));
+    EXPECT_CALL(*handle2, obtainReader(&client)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*reader2, read(buffer, sizeof(buffer), kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(4));
 
-    // They are adopted by |obtainReader|.
-    ASSERT_TRUE(reader1.release());
-    ASSERT_TRUE(reader2.release());
-
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
     std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(&client);
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(2);
     updater->update(std::move(handle2));
     checkpoint.Call(3);
     EXPECT_EQ(kOk, reader->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(4);
 }
 
 TEST(CompositeDataConsumerHandleTest, TwoPhaseRead)
 {
     const void* p = nullptr;
     size_t size = 0;
     Checkpoint checkpoint;
 
     std::unique_ptr<MockHandle> handle1 = MockHandle::create();
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
-    std::unique_ptr<MockReader> reader1 = MockReader::create();
-    std::unique_ptr<MockReader> reader2 = MockReader::create();
+
+    // They are adopted by |obtainReader|.
+    MockReader* reader1 = MockReader::create().release();
+    MockReader* reader2 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReaderInternal(nullptr)).WillOnce(Return(reader1.get()));
+    EXPECT_CALL(*handle1, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*reader1, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(3));
-    EXPECT_CALL(*handle2, obtainReaderInternal(nullptr)).WillOnce(Return(reader2.get()));
+    EXPECT_CALL(*handle2, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*reader2, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(5));
     EXPECT_CALL(*reader2, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(6));
 
-    // They are adopted by |obtainReader|.
-    ASSERT_TRUE(reader1.release());
-    ASSERT_TRUE(reader2.release());
-
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
     std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(2);
     EXPECT_EQ(kOk, reader->endRead(0));
     checkpoint.Call(3);
     updater->update(std::move(handle2));
     checkpoint.Call(4);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(5);
     EXPECT_EQ(kOk, reader->endRead(0));
     checkpoint.Call(6);
 }
 
 TEST(CompositeDataConsumerHandleTest, HangingTwoPhaseRead)
 {
     const void* p = nullptr;
     size_t size = 0;
     Checkpoint checkpoint;
 
     std::unique_ptr<MockHandle> handle1 = MockHandle::create();
     std::unique_ptr<MockHandle> handle2 = MockHandle::create();
     std::unique_ptr<MockHandle> handle3 = MockHandle::create();
-    std::unique_ptr<MockReader> reader1 = MockReader::create();
-    std::unique_ptr<MockReader> reader2 = MockReader::create();
-    std::unique_ptr<MockReader> reader3 = MockReader::create();
+
+    // They are adopted by |obtainReader|.
+    MockReader* reader1 = MockReader::create().release();
+    MockReader* reader2 = MockReader::create().release();
+    MockReader* reader3 = MockReader::create().release();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*handle1, obtainReaderInternal(nullptr)).WillOnce(Return(reader1.get()));
+    EXPECT_CALL(*handle1, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader1))));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*reader1, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*reader1, endRead(0)).WillOnce(Return(kOk));
-    EXPECT_CALL(*handle2, obtainReaderInternal(nullptr)).WillOnce(Return(reader2.get()));
+    EXPECT_CALL(*handle2, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader2))));
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*reader2, beginRead(&p, kNone, &size)).WillOnce(Return(kShouldWait));
     EXPECT_CALL(checkpoint, Call(5));
-    EXPECT_CALL(*handle3, obtainReaderInternal(nullptr)).WillOnce(Return(reader3.get()));
+    EXPECT_CALL(*handle3, obtainReader(nullptr)).WillOnce(Return(ByMove(WTF::wrapUnique(reader3))));
     EXPECT_CALL(checkpoint, Call(6));
     EXPECT_CALL(*reader3, beginRead(&p, kNone, &size)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(7));
     EXPECT_CALL(*reader3, endRead(0)).WillOnce(Return(kOk));
     EXPECT_CALL(checkpoint, Call(8));
 
-    // They are adopted by |obtainReader|.
-    ASSERT_TRUE(reader1.release());
-    ASSERT_TRUE(reader2.release());
-    ASSERT_TRUE(reader3.release());
-
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     std::unique_ptr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::create(std::move(handle1), &updater);
     checkpoint.Call(0);
     std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     checkpoint.Call(1);
     EXPECT_EQ(kOk, reader->beginRead(&p, kNone, &size));
     checkpoint.Call(2);
     updater->update(std::move(handle2));
     checkpoint.Call(3);
     EXPECT_EQ(kOk, reader->endRead(0));
@@ skipping 83 matching lines @@
 {
     RefPtr<DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest> test = DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest::create();
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     // Test this function doesn't crash.
     test->run(CompositeDataConsumerHandle::create(createDoneDataConsumerHandle(), &updater));
 }
 
 } // namespace
 
 } // namespace blink