PaymentRequest: Implement PaymentDetailsModifier dictionary (in blink side).

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"
@@ skipping 14 matching lines @@
 #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::PaymentCurrencyAmount;
 using blink::mojom::blink::PaymentCurrencyAmountPtr;
 using blink::mojom::blink::PaymentDetails;
+using blink::mojom::blink::PaymentDetailsModifier;
+using blink::mojom::blink::PaymentDetailsModifierPtr;
 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::PaymentShippingOption;
 using blink::mojom::blink::PaymentShippingOptionPtr;
 
@@ skipping 26 matching lines @@
         PaymentShippingOptionPtr output = PaymentShippingOption::New();
         output->id = input.id();
         output->label = input.label();
         output->amount = PaymentCurrencyAmount::From(input.amount());
         output->selected = input.hasSelected() && input.selected();
         return output;
     }
 };
 
 template <>
+struct TypeConverter<PaymentDetailsModifierPtr, blink::PaymentDetailsModifier> {
+    static PaymentDetailsModifierPtr Convert(const blink::PaymentDetailsModifier& input)
+    {
+        PaymentDetailsModifierPtr output = PaymentDetailsModifier::New();
+        output->supported_methods = WTF::Vector<WTF::String>(input.supportedMethods());
+
+        if (input.hasTotal())
+            output->total = PaymentItem::From(input.total());
+        else
+            output->total = PaymentItem::New();
+
+        if (input.hasAdditionalDisplayItems())
+            output->additional_display_items = mojo::WTFArray<PaymentItemPtr>::From(input.additionalDisplayItems());
+        else
+            output->additional_display_items = mojo::WTFArray<PaymentItemPtr>::New(0);
+
+        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<PaymentShippingOptionPtr>::From(input.shippingOptions());
         else
             output->shipping_options = mojo::WTFArray<PaymentShippingOptionPtr>::New(0);
 
+        if (input.hasModifiers())
+            output->modifiers = mojo::WTFArray<PaymentDetailsModifierPtr>::From(input.modifiers());
+        else
+            output->modifiers = mojo::WTFArray<PaymentDetailsModifierPtr>::New(0);
+
         return output;
     }
 };
 
 template <>
 struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
     static PaymentOptionsPtr Convert(const blink::PaymentOptions& input)
     {
         PaymentOptionsPtr output = PaymentOptions::New();
         output->request_payer_email = input.requestPayerEmail();
@@ skipping 75 matching lines @@
             exceptionState.throwTypeError("ShippingOption id required");
             return;
         }
 
         validateShippingOptionOrPaymentItem(option, exceptionState);
         if (exceptionState.hadException())
             return;
     }
 }
 
+void validatePaymentDetailsModifiers(const HeapVector<PaymentDetailsModifier>& modifiers, ExceptionState& exceptionState)
+{
+    if (modifiers.isEmpty()) {
+        exceptionState.throwTypeError("Must specify at least one payment details modifier");
+        return;
+    }
+
+    for (const auto& modifier : modifiers) {
+        if (modifier.supportedMethods().isEmpty()) {
+            exceptionState.throwTypeError("Must specify at least one payment method identifier");
+            return;
+        }
+
+        if (modifier.hasTotal()) {
+            validateShippingOptionOrPaymentItem(modifier.total(), exceptionState);
+            if (exceptionState.hadException())
+                return;
+
+            if (modifier.total().amount().value()[0] == '-') {
+                exceptionState.throwTypeError("Total amount value should be non-negative");
+                return;
+            }
+        }
+
+        if (modifier.hasAdditionalDisplayItems()) {
+            validateDisplayItems(modifier.additionalDisplayItems(), exceptionState);
+            if (exceptionState.hadException())
+                return;
+        }
+    }
+}
+
 void validatePaymentDetails(const PaymentDetails& details, ExceptionState& exceptionState)
 {
     if (!details.hasTotal()) {
         exceptionState.throwTypeError("Must specify total");
         return;
     }
 
     validateShippingOptionOrPaymentItem(details.total(), exceptionState);
     if (exceptionState.hadException())
         return;
 
     if (details.total().amount().value()[0] == '-') {
         exceptionState.throwTypeError("Total amount value should be non-negative");
         return;
     }
 
     if (details.hasDisplayItems()) {
         validateDisplayItems(details.displayItems(), exceptionState);
         if (exceptionState.hadException())
             return;
     }
 
     if (details.hasShippingOptions()) {
         validateShippingOptions(details.shippingOptions(), exceptionState);
+        if (exceptionState.hadException())
+            return;
+    }
+
+    if (details.hasModifiers()) {
+        validatePaymentDetailsModifiers(details.modifiers(), exceptionState);
     }
 }
 
 void validateAndConvertPaymentMethodData(const HeapVector<PaymentMethodData>& paymentMethodData, Vector<PaymentRequest::MethodData>* methodData, ExceptionState& exceptionState)
 {
     if (paymentMethodData.isEmpty()) {
         exceptionState.throwTypeError("Must specify at least one payment method identifier");
         return;
     }
 
@@ skipping 315 matching lines @@
 {
     m_completeResolver.clear();
     m_showResolver.clear();
     m_abortResolver.clear();
     if (m_clientBinding.is_bound())
         m_clientBinding.Close();
     m_paymentProvider.reset();
 }
 
 } // namespace blink