Rename FormData/FormDataBuilder to EncodedFormData/FormDataEncoder respectively.

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 "config.h"
 #include "modules/fetch/FetchFormDataConsumerHandle.h"
 
 #include "core/dom/DOMTypedArray.h"
 #include "core/html/DOMFormData.h"
 #include "core/html/FormDataList.h"
@@ skipping 58 matching lines @@
 class FetchFormDataConsumerHandleTest : public ::testing::Test {
 public:
     FetchFormDataConsumerHandleTest() : m_page(DummyPageHolder::create(IntSize(1, 1))) {}
 
 protected:
     Document* document() { return &m_page->document(); }
 
     OwnPtr<DummyPageHolder> m_page;
 };
 
-PassRefPtr<FormData> complexFormData()
+PassRefPtr<EncodedFormData> complexFormData()
 {
-    RefPtr<FormData> data = FormData::create();
+    RefPtr<EncodedFormData> data = EncodedFormData::create();
 
     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();
     blobData->appendText("hello", false);
     auto size = blobData->length();
     RefPtr<BlobDataHandle> blobDataHandle = BlobDataHandle::create(blobData.release(), size);
     data->appendBlob(blobDataHandle->uuid(), blobDataHandle);
     Vector<char> boundary;
     boundary.append("\0", 1);
     data->setBoundary(boundary);
     return data.release();
 }
 
-void verifyComplexFormData(FormData* data)
+void verifyComplexFormData(EncodedFormData* data)
 {
     const auto& elements = data->elements();
     if (4 != elements.size()) {
         FAIL() << "data->elements().size() should be 4, but is " << data->elements().size() << ".";
     }
     EXPECT_EQ(FormDataElement::data, elements[0].m_type);
     EXPECT_EQ("foo", String(elements[0].m_data.data(), elements[0].m_data.size()));
 
     EXPECT_EQ(FormDataElement::encodedFile, elements[1].m_type);
     EXPECT_EQ("/foo/bar/baz", elements[1].m_filename);
@@ skipping 65 matching lines @@
     HandleReaderRunner<HandleReader> runner(handle.release());
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     Vector<char> expected;
     expected.append(data + offset, size);
     EXPECT_EQ(expected, r->data());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, ReadFromSimplFormData)
 {
-    RefPtr<FormData> data = FormData::create();
+    RefPtr<EncodedFormData> data = EncodedFormData::create();
     data->appendData("foo", 3);
     data->appendData("hoge", 4);
 
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(document(), data);
     HandleReaderRunner<HandleReader> runner(handle.release());
     testing::runPendingTasks();
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("foohoge", toString(r->data()));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, ReadFromComplexFormData)
 {
-    RefPtr<FormData> data = complexFormData();
+    RefPtr<EncodedFormData> data = complexFormData();
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(document(), data, new LoaderFactory(src.release()));
     char c;
     size_t readSize;
     EXPECT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(&c, 1, kNone, &readSize));
 
     HandleReaderRunner<HandleReader> runner(handle.release());
     testing::runPendingTasks();
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("bar", toString(r->data()));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, TwoPhaseReadFromComplexFormData)
 {
-    RefPtr<FormData> data = complexFormData();
+    RefPtr<EncodedFormData> data = complexFormData();
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(document(), data, new LoaderFactory(src.release()));
     char c;
     size_t readSize;
     EXPECT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(&c, 1, kNone, &readSize));
 
     HandleReaderRunner<HandleTwoPhaseReader> runner(handle.release());
     testing::runPendingTasks();
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("bar", toString(r->data()));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsBlobDataHandle)
 {
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     EXPECT_FALSE(reader->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize));
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromString)
 {
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-    RefPtr<FormData> formData = reader->drainAsFormData();
+    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)
 {
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(DOMArrayBuffer::create("foo", 3));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-    RefPtr<FormData> formData = reader->drainAsFormData();
+    RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     EXPECT_EQ("foo", formData->flattenToString());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, DrainAsFormDataFromSimpleFormData)
 {
     DOMFormData* data = DOMFormData::create(UTF8Encoding());
     data->append("name1", "value1");
     data->append("name2", "value2");
-    RefPtr<FormData> inputFormData = data->createMultiPartFormData();
+    RefPtr<EncodedFormData> inputFormData = data->createMultiPartFormData();
 
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(document(), inputFormData);
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-    RefPtr<FormData> outputFormData = reader->drainAsFormData();
+    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<FormData> inputFormData = complexFormData();
+    RefPtr<EncodedFormData> inputFormData = complexFormData();
 
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(document(), inputFormData);
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-    RefPtr<FormData> outputFormData = reader->drainAsFormData();
+    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)
 {
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     size_t readSize;
     EXPECT_EQ(kOk, reader->read(nullptr, 0, kNone, &readSize));
-    RefPtr<FormData> formData = reader->drainAsFormData();
+    RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     EXPECT_EQ("hello, world", formData->flattenToString());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDraining)
 {
     char c;
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::create(String("hello, world"));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
@@ skipping 22 matching lines @@
 {
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
     OwnPtr<FetchDataConsumerHandle> handle = FetchFormDataConsumerHandle::createForTest(document(), complexFormData(), new LoaderFactory(src.release()));
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(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<FormData> formData = reader->drainAsFormData();
+    RefPtr<EncodedFormData> formData = reader->drainAsFormData();
     ASSERT_TRUE(formData);
     EXPECT_TRUE(formData->isSafeToSendToAnotherThread());
     verifyComplexFormData(formData.get());
 }
 
 TEST_F(FetchFormDataConsumerHandleTest, OneByteReadAffectsDrainingForComplexFormData)
 {
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Data, "bar"));
     src->add(Command(Command::Done));
@@ skipping 21 matching lines @@
     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