Migrate WTF::Vector::append() to ::push_back() [part 13 of N]

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

 // Copyright 2014 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/Response.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
@@ skipping 20 matching lines @@
   const unsigned short status = 200;
   const String statusText = "the best status text";
   struct {
     const char* key;
     const char* value;
   } headers[] = {{"cache-control", "no-cache"},
                  {"set-cookie", "foop"},
                  {"foo", "bar"},
                  {0, 0}};
   Vector<WebURL> urlList;
-  urlList.append(url);
+  urlList.push_back(url);
   std::unique_ptr<WebServiceWorkerResponse> webResponse =
       WTF::makeUnique<WebServiceWorkerResponse>();
   webResponse->setURLList(urlList);
   webResponse->setStatus(status);
   webResponse->setStatusText(statusText);
   webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
   for (int i = 0; headers[i].key; ++i)
     webResponse->setHeader(WebString::fromUTF8(headers[i].key),
                            WebString::fromUTF8(headers[i].value));
   return webResponse;
 }
 
 TEST(ServiceWorkerResponseTest, FromFetchResponseData) {
   std::unique_ptr<DummyPageHolder> page =
       DummyPageHolder::create(IntSize(1, 1));
   const KURL url(ParsedURLString, "http://www.response.com");
 
   FetchResponseData* fetchResponseData = FetchResponseData::create();
   Vector<KURL> urlList;
-  urlList.append(url);
+  urlList.push_back(url);
   fetchResponseData->setURLList(urlList);
   Response* response = Response::create(&page->document(), fetchResponseData);
   ASSERT(response);
   EXPECT_EQ(url, response->url());
 }
 
 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) {
   V8TestingScope scope;
   std::unique_ptr<WebServiceWorkerResponse> webResponse =
       createTestWebServiceWorkerResponse();
@@ skipping 149 matching lines @@
   src->add(Command(Command::Done));
   return new BodyStreamBuffer(scriptState, src);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
   Vector<KURL> urlList;
-  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  urlList.push_back(KURL(ParsedURLString, "http://www.response.com"));
   fetchResponseData->setURLList(urlList);
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
   Vector<KURL> urlList;
-  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  urlList.push_back(KURL(ParsedURLString, "http://www.response.com"));
   fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createBasicFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
   Vector<KURL> urlList;
-  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  urlList.push_back(KURL(ParsedURLString, "http://www.response.com"));
   fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createCORSFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
   Vector<KURL> urlList;
-  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  urlList.push_back(KURL(ParsedURLString, "http://www.response.com"));
   fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, false);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneError) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = new BodyStreamBuffer(
       scope.getScriptState(),
       BytesConsumer::createErrored(BytesConsumer::Error()));
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
   Vector<KURL> urlList;
-  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  urlList.push_back(KURL(ParsedURLString, "http://www.response.com"));
   fetchResponseData->setURLList(urlList);
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   DummyExceptionStateForTesting exceptionState;
   Response* clonedResponse =
       response->clone(scope.getScriptState(), exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   BytesConsumerTestUtil::MockFetchDataLoaderClient* client1 =
       new BytesConsumerTestUtil::MockFetchDataLoaderClient();
   BytesConsumerTestUtil::MockFetchDataLoaderClient* client2 =
       new BytesConsumerTestUtil::MockFetchDataLoaderClient();
   EXPECT_CALL(*client1, didFetchDataLoadFailed());
   EXPECT_CALL(*client2, didFetchDataLoadFailed());
 
   response->internalBodyBuffer()->startLoading(
       FetchDataLoader::createLoaderAsString(), client1);
   clonedResponse->internalBodyBuffer()->startLoading(
       FetchDataLoader::createLoaderAsString(), client2);
   blink::testing::runPendingTasks();
 }
 
 }  // namespace
 }  // namespace blink