Rename remaining types so that all begin Payment*

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/JSONValuesForV8.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/modules/v8/V8PaymentDetails.h"
 #include "core/EventTypeNames.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/Event.h"
 #include "core/events/EventQueue.h"
 #include "modules/EventTargetModulesNames.h"
 #include "modules/payments/PaymentAddress.h"
 #include "modules/payments/PaymentItem.h"
 #include "modules/payments/PaymentRequestUpdateEvent.h"
 #include "modules/payments/PaymentResponse.h"
+#include "modules/payments/PaymentShippingOption.h"
 #include "modules/payments/PaymentsValidators.h"
-#include "modules/payments/ShippingOption.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/wtf_array.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/ServiceRegistry.h"
 #include <utility>
 
 namespace mojo {
 
-using blink::mojom::blink::CurrencyAmount;
-using blink::mojom::blink::CurrencyAmountPtr;
+using blink::mojom::blink::PaymentCurrencyAmount;
+using blink::mojom::blink::PaymentCurrencyAmountPtr;
 using blink::mojom::blink::PaymentDetails;
 using blink::mojom::blink::PaymentDetailsPtr;
 using blink::mojom::blink::PaymentItem;
 using blink::mojom::blink::PaymentItemPtr;
 using blink::mojom::blink::PaymentMethodData;
 using blink::mojom::blink::PaymentMethodDataPtr;
 using blink::mojom::blink::PaymentOptions;
 using blink::mojom::blink::PaymentOptionsPtr;
-using blink::mojom::blink::ShippingOption;
-using blink::mojom::blink::ShippingOptionPtr;
+using blink::mojom::blink::PaymentShippingOption;
+using blink::mojom::blink::PaymentShippingOptionPtr;
 
 template <>
-struct TypeConverter<CurrencyAmountPtr, blink::CurrencyAmount> {
-    static CurrencyAmountPtr Convert(const blink::CurrencyAmount& input)
+struct TypeConverter<PaymentCurrencyAmountPtr, blink::PaymentCurrencyAmount> {
+    static PaymentCurrencyAmountPtr Convert(const blink::PaymentCurrencyAmount& input)
     {
-        CurrencyAmountPtr output = CurrencyAmount::New();
+        PaymentCurrencyAmountPtr output = PaymentCurrencyAmount::New();
         output->currency = input.currency();
         output->value = input.value();
         return output;
     }
 };
 
 template <>
 struct TypeConverter<PaymentItemPtr, blink::PaymentItem> {
     static PaymentItemPtr Convert(const blink::PaymentItem& input)
     {
         PaymentItemPtr output = PaymentItem::New();
         output->label = input.label();
-        output->amount = CurrencyAmount::From(input.amount());
+        output->amount = PaymentCurrencyAmount::From(input.amount());
         return output;
     }
 };
 
 template <>
-struct TypeConverter<ShippingOptionPtr, blink::ShippingOption> {
-    static ShippingOptionPtr Convert(const blink::ShippingOption& input)
+struct TypeConverter<PaymentShippingOptionPtr, blink::PaymentShippingOption> {
+    static PaymentShippingOptionPtr Convert(const blink::PaymentShippingOption& input)
     {
-        ShippingOptionPtr output = ShippingOption::New();
+        PaymentShippingOptionPtr output = PaymentShippingOption::New();
         output->id = input.id();
         output->label = input.label();
-        output->amount = CurrencyAmount::From(input.amount());
+        output->amount = PaymentCurrencyAmount::From(input.amount());
         output->selected = input.hasSelected() && input.selected();
         return output;
     }
 };
 
 template <>
 struct TypeConverter<PaymentDetailsPtr, blink::PaymentDetails> {
     static PaymentDetailsPtr Convert(const blink::PaymentDetails& input)
     {
         PaymentDetailsPtr output = PaymentDetails::New();
         output->total = PaymentItem::From(input.total());
 
         if (input.hasDisplayItems())
             output->display_items = mojo::WTFArray<PaymentItemPtr>::From(input.displayItems());
         else
             output->display_items = mojo::WTFArray<PaymentItemPtr>::New(0);
 
         if (input.hasShippingOptions())
-            output->shipping_options = mojo::WTFArray<ShippingOptionPtr>::From(input.shippingOptions());
+            output->shipping_options = mojo::WTFArray<PaymentShippingOptionPtr>::From(input.shippingOptions());
         else
-            output->shipping_options = mojo::WTFArray<ShippingOptionPtr>::New(0);
+            output->shipping_options = mojo::WTFArray<PaymentShippingOptionPtr>::New(0);
 
         return output;
     }
 };
 
 template <>
 struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
     static PaymentOptionsPtr Convert(const blink::PaymentOptions& input)
     {
         PaymentOptionsPtr output = PaymentOptions::New();
@@ skipping 60 matching lines @@
 
 void validateDisplayItems(const HeapVector<PaymentItem>& items, ExceptionState& exceptionState)
 {
     for (const auto& item : items) {
         validateShippingOptionOrPaymentItem(item, exceptionState);
         if (exceptionState.hadException())
             return;
     }
 }
 
-void validateShippingOptions(const HeapVector<ShippingOption>& options, ExceptionState& exceptionState)
+void validateShippingOptions(const HeapVector<PaymentShippingOption>& options, ExceptionState& exceptionState)
 {
     for (const auto& option : options) {
         if (!option.hasId() || option.id().isEmpty()) {
             exceptionState.throwTypeError("ShippingOption id required");
             return;
         }
 
         validateShippingOptionOrPaymentItem(option, exceptionState);
         if (exceptionState.hadException())
             return;
@@ skipping 348 matching lines @@
 {
     m_completeResolver.clear();
     m_showResolver.clear();
     m_abortResolver.clear();
     if (m_clientBinding.is_bound())
         m_clientBinding.Close();
     m_paymentProvider.reset();
 }
 
 } // namespace blink