Return unique_ptr<WebDataConsumerHandle::Reader> directly from obtainReader

third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.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/FetchFormDataConsumerHandle.h"
 
 #include "core/dom/DOMTypedArray.h"
 #include "core/html/FormData.h"
 #include "core/loader/MockThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
@@ skipping 219 matching lines @@
     HandleReaderRunner<HandleTwoPhaseReader> runner(std::move(handle));
     testing::runPendingTasks();
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("bar", toString(r->data()));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromString)
 {
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();
     ASSERT_TRUE(blobDataHandle);
 
     EXPECT_EQ(String(), blobDataHandle->type());
     EXPECT_EQ(12u, blobDataHandle->size());
     EXPECT_EQ(nullptr, reader->drainAsFormData());
     char c;
     size_t readSize;
     EXPECT_EQ(kDone, reader->read(&c, 1, kNone, &readSize));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromArrayBuffer)
 {
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();
     ASSERT_TRUE(blobDataHandle);
 
     EXPECT_EQ(String(), blobDataHandle->type());
     EXPECT_EQ(3u, blobDataHandle->size());
     EXPECT_EQ(nullptr, reader->drainAsFormData());
     char c;
     size_t readSize;
     EXPECT_EQ(kDone, reader->read(&c, 1, kNone, &readSize));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromSimpleFormData)
 {
     FormData* data = FormData::create(UTF8Encoding());
     data->append("name1", "value1");
     data->append("name2", "value2");
     RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData();
 
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();
     ASSERT_TRUE(blobDataHandle);
 
     EXPECT_EQ(String(), blobDataHandle->type());
     EXPECT_EQ(inputFormData->flattenToString().utf8().length(), blobDataHandle->size());
     EXPECT_EQ(nullptr, reader->drainAsFormData());
     char c;
     size_t readSize;
     EXPECT_EQ(kDone, reader->read(&c, 1, kNone, &readSize));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandleFromComplexFormData)
 {
     RefPtr<EncodedFormData> inputFormData = complexFormData();
 
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<BlobDataHandle> blobDataHandle = reader->drainAsBlobDataHandle();
     ASSERT_TRUE(blobDataHandle);
 
     EXPECT_EQ(nullptr, reader->drainAsFormData());
     char c;
     size_t readSize;
     EXPECT_EQ(kDone, reader->read(&c, 1, kNone, &readSize));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromString)
 {
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     EXPECT_EQ("hello, world", formData->flattenToString());
 
     const void* buffer = nullptr;
     size_t size;
     EXPECT_EQ(kDone, reader->read(nullptr, 0, kNone, &size));
     EXPECT_EQ(kDone, reader->beginRead(&buffer, kNone, &size));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromArrayBuffer)
 {
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     EXPECT_EQ("foo", formData->flattenToString());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromSimpleFormData)
 {
     FormData* data = FormData::create(UTF8Encoding());
     data->append("name1", "value1");
     data->append("name2", "value2");
     RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData();
 
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<EncodedFormData> outputFormData = reader->drainAsFormData();
     ASSERT_TRUE(outputFormData);
     EXPECT_TRUE(outputFormData->isSafeToSendToAnotherThread());
     EXPECT_NE(outputFormData.get(), inputFormData.get());
     EXPECT_EQ(inputFormData->flattenToString(), outputFormData->flattenToString());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromComplexFormData)
 {
     RefPtr<EncodedFormData> inputFormData = complexFormData();
 
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(getDocument(), inputFormData);
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     RefPtr<EncodedFormData> outputFormData = reader->drainAsFormData();
     ASSERT_TRUE(outputFormData);
     EXPECT_TRUE(outputFormData->isSafeToSendToAnotherThread());
     EXPECT_NE(outputFormData.get(), inputFormData.get());
     verifyComplexFormData(outputFormData.get());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDraining)
 {
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     size_t readSize;
     EXPECT_EQ(kOk, reader->read(nullptr, 0, kNone, &readSize));
     RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     EXPECT_EQ("hello, world", formData->flattenToString());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDraining)
 {
     char c;
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     size_t readSize;
     EXPECT_EQ(kOk, reader->read(&c, 1, kNone, &readSize));
     EXPECT_EQ(1u, readSize);
     EXPECT_EQ('h', c);
     EXPECT_FALSE(reader->drainAsFormData());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, BeginReadAffectsDraining)
 {
     const void* buffer = nullptr;
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     size_t available;
     EXPECT_EQ(kOk, reader->beginRead(&buffer, kNone, &available));
     ASSERT_TRUE(buffer);
     EXPECT_EQ("hello, world", String(static_cast<const char*>(buffer), available));
     EXPECT_FALSE(reader->drainAsFormData());
     reader->endRead(0);
     EXPECT_FALSE(reader->drainAsFormData());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, ZeroByteReadDoesNotAffectDrainingForComplexFormData)
 {
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     size_t readSize;
     EXPECT_EQ(kShouldWait, reader->read(nullptr, 0, kNone, &readSize));
     testing::runPendingTasks();
     EXPECT_EQ(kOk, reader->read(nullptr, 0, kNone, &readSize));
     RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     verifyComplexFormData(formData.get());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDrainingForComplexFormData)
 {
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     char c;
     size_t readSize;
     EXPECT_EQ(kShouldWait, reader->read(&c, 1, kNone, &readSize));
     testing::runPendingTasks();
     EXPECT_EQ(kOk, reader->read(&c, 1, kNone, &readSize));
     EXPECT_EQ(1u, readSize);
     EXPECT_EQ('b', c);
     EXPECT_FALSE(reader->drainAsFormData());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, BeginReadAffectsDrainingForComplexFormData)
 {
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     const void* buffer = nullptr;
     std::unique_ptr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(getDocument(), complexFormData(), new LoaderFactory(std::move(src)));
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
     size_t available;
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     EXPECT_EQ(kOk, reader->beginRead(&buffer, kNone, &available));
     EXPECT_FALSE(reader->drainAsFormData());
     reader->endRead(0);
     EXPECT_FALSE(reader->drainAsFormData());
 }
 
 } // namespace
 } // namespace blink