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

third_party/WebKit/Source/modules/payments/PaymentRequest.cpp

 // Copyright 2016 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/payments/PaymentRequest.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8StringResource.h"
@@ skipping 168 matching lines @@
   }
 }
 
 void validateAndConvertDisplayItems(const HeapVector<PaymentItem>& input,
                                     Vector<PaymentItemPtr>& output,
                                     ExceptionState& exceptionState) {
   for (const PaymentItem& item : input) {
     validateShippingOptionOrPaymentItem(item, exceptionState);
     if (exceptionState.hadException())
       return;
-    output.append(payments::mojom::blink::PaymentItem::From(item));
+    output.push_back(payments::mojom::blink::PaymentItem::From(item));
   }
 }
 
 // Validates and converts |input| shipping options into |output|. Throws an
 // exception if the data is not valid, except for duplicate identifiers, which
 // returns an empty |output| instead of throwing an exception. There's no need
 // to clear |output| when an exception is thrown, because the caller takes care
 // of deleting |output|.
 void validateAndConvertShippingOptions(
     const HeapVector<PaymentShippingOption>& input,
@@ skipping 11 matching lines @@
       output.clear();
       return;
     }
 
     uniqueIds.add(option.id());
 
     validateShippingOptionOrPaymentItem(option, exceptionState);
     if (exceptionState.hadException())
       return;
 
-    output.append(payments::mojom::blink::PaymentShippingOption::From(option));
+    output.push_back(
+        payments::mojom::blink::PaymentShippingOption::From(option));
   }
 }
 
 void validateAndConvertTotal(const PaymentItem& input,
                              PaymentItemPtr& output,
                              ExceptionState& exceptionState) {
   validateShippingOptionOrPaymentItem(input, exceptionState);
   if (exceptionState.hadException())
     return;
 
@@ skipping 29 matching lines @@
         androidPay.minGooglePlayServicesVersion().toIntStrict(&ok);
     if (ok) {
       output->min_google_play_services_version = minGooglePlayServicesVersion;
     }
   }
 
   if (androidPay.hasAllowedCardNetworks()) {
     for (const String& allowedCardNetwork : androidPay.allowedCardNetworks()) {
       for (size_t i = 0; i < arraysize(kAndroidPayNetwork); ++i) {
         if (allowedCardNetwork == kAndroidPayNetwork[i].name) {
-          output->allowed_card_networks.append(kAndroidPayNetwork[i].code);
+          output->allowed_card_networks.push_back(kAndroidPayNetwork[i].code);
           break;
         }
       }
     }
   }
 
   if (androidPay.hasPaymentMethodTokenizationParameters()) {
     const blink::AndroidPayTokenization& tokenization =
         androidPay.paymentMethodTokenizationParameters();
     output->tokenization_type =
@@ skipping 10 matching lines @@
 
     if (tokenization.hasParameters()) {
       const Vector<String>& keys =
           tokenization.parameters().getPropertyNames(exceptionState);
       if (exceptionState.hadException())
         return;
       String value;
       for (const String& key : keys) {
         if (!DictionaryHelper::get(tokenization.parameters(), key, value))
           continue;
-        output->parameters.append(
+        output->parameters.push_back(
             payments::mojom::blink::AndroidPayTokenizationParameter::New());
         output->parameters.back()->key = key;
         output->parameters.back()->value = value;
       }
     }
   }
 }
 
 void stringifyAndParseMethodSpecificData(const ScriptValue& input,
                                          PaymentMethodDataPtr& output,
@@ skipping 21 matching lines @@
     const HeapVector<PaymentDetailsModifier>& input,
     Vector<PaymentDetailsModifierPtr>& output,
     ExceptionState& exceptionState) {
   if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment details modifier");
     return;
   }
 
   for (const PaymentDetailsModifier& modifier : input) {
-    output.append(payments::mojom::blink::PaymentDetailsModifier::New());
+    output.push_back(payments::mojom::blink::PaymentDetailsModifier::New());
     if (modifier.hasTotal()) {
       validateAndConvertTotal(modifier.total(), output.back()->total,
                               exceptionState);
       if (exceptionState.hadException())
         return;
     }
 
     if (modifier.hasAdditionalDisplayItems()) {
       validateAndConvertDisplayItems(modifier.additionalDisplayItems(),
                                      output.back()->additional_display_items,
@@ skipping 91 matching lines @@
     return;
   }
 
   for (const PaymentMethodData paymentMethodData : input) {
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
-    output.append(payments::mojom::blink::PaymentMethodData::New());
+    output.push_back(payments::mojom::blink::PaymentMethodData::New());
     output.back()->supported_methods = paymentMethodData.supportedMethods();
 
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
       stringifyAndParseMethodSpecificData(paymentMethodData.data(),
                                           output.back(), exceptionState);
     } else {
       output.back()->stringified_data = "";
     }
   }
 }
@@ skipping 453 matching lines @@
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
   m_canMakePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink