Move payment_request.mojom file to components/

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 76 matching lines @@
       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());

[please use gerrit instead, 2016/10/12 23:51:55]

Is it not possible to continue using WTFArray::From()?

[Kevin Bailey, 2016/10/13 18:30:42]

The destination field has changed from mojo::WTFArray to WTF::Vector.

[please use gerrit instead, 2016/10/13 20:24:00]

Please see if there's a shorter way to write this, like a copy constructor.

-    else
-      output->additional_display_items = mojo::WTFArray<PaymentItemPtr>::New(0);
-
+    if (input.hasAdditionalDisplayItems()) {
+      for (size_t i = 0; i < input.additionalDisplayItems().size(); ++i) {
+        output->additional_display_items.append(
+            TypeConverter<PaymentItemPtr, blink::PaymentItem>::Convert(
+                input.additionalDisplayItems()[i]));

[please use gerrit instead, 2016/10/12 23:51:55]

It's shorter to call "PaymentItem::From()" instead of
"TypeConverter<PaymentItemPtr, blink::PaymentItem>::Convert()". See line 93 for
an example. They are equivalent in functionality, though.

[Kevin Bailey, 2016/10/13 18:30:42]

Ok, changed all 4 occurrences.

+      }
+    }
     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.hasDisplayItems()) {
+      for (size_t i = 0; i < input.displayItems().size(); ++i) {
+        output->display_items.append(
+            TypeConverter<PaymentItemPtr, blink::PaymentItem>::Convert(
+                input.displayItems()[i]));
+      }
+    }
 
-    if (input.hasShippingOptions())
-      output->shipping_options = mojo::WTFArray<PaymentShippingOptionPtr>::From(
-          input.shippingOptions());
-    else
-      output->shipping_options =
-          mojo::WTFArray<PaymentShippingOptionPtr>::New(0);
+    if (input.hasShippingOptions()) {
+      for (size_t i = 0; i < input.shippingOptions().size(); ++i) {
+        output->shipping_options.append(
+            TypeConverter<PaymentShippingOptionPtr,
+                          blink::PaymentShippingOption>::
+                Convert(input.shippingOptions()[i]));
+      }
+    }
 
-    if (input.hasModifiers())
-      output->modifiers =
-          mojo::WTFArray<PaymentDetailsModifierPtr>::From(input.modifiers());
-    else
-      output->modifiers = mojo::WTFArray<PaymentDetailsModifierPtr>::New(0);
+    if (input.hasModifiers()) {
+      for (size_t i = 0; i < input.modifiers().size(); ++i) {
+        output->modifiers.append(
+            TypeConverter<
+                PaymentDetailsModifierPtr,
+                blink::PaymentDetailsModifier>::Convert(input.modifiers()[i]));
+      }
+    }
 
     if (input.hasError())
       output->error = input.error();
     else
       output->error = WTF::emptyString();
 
     return output;
   }
 };
 
@@ skipping 21 matching lines @@
           WTF::Vector<WTF::String>(input[i].supportedMethods);
       output[i]->stringified_data = input[i].stringifiedData;
     }
     return output;
   }
 };
 
 }  // namespace mojo
 
 namespace blink {
+
+bool validatePaymentDetails(const mojo::PaymentDetailsPtr&);

[please use gerrit instead, 2016/10/12 23:51:55]

Pretty sure that this declaration is no-op, because the only definition is
inside of the anonymous namespace on line 305. Please remove.

[Kevin Bailey, 2016/10/13 18:30:42]

Was left-over. Gone.

+
 namespace {
 
 // If the website does not call complete() 60 seconds after show() has been
 // resolved, then behave as if the website called complete("fail").
 static const int completeTimeoutSeconds = 60;
 
 // Validates ShippingOption or PaymentItem, which happen to have identical
 // fields, except for "id", which is present only in ShippingOption.
 template <typename T>
 void validateShippingOptionOrPaymentItem(const T& item,
@@ skipping 399 matching lines @@
     exceptionState.throwSecurityError("Must be in a secure context");
     return;
   }
 
   if (!scriptState->domWindow()->frame() ||
       !scriptState->domWindow()->frame()->isMainFrame()) {
     exceptionState.throwSecurityError(
         "Must be in a top-level browsing context");
     return;
   }
-
-  validatePaymentDetails(details, exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (details.hasError() && !details.error().isEmpty()) {
     exceptionState.throwTypeError("Error value should be empty");
     return;
   }
 
   if (m_options.requestShipping()) {
     m_shippingOption = getSelectedShippingOption(details);
     m_shippingType = getValidShippingType(m_options.shippingType());
   }
 
   scriptState->domWindow()->frame()->interfaceProvider()->getInterface(
       mojo::GetProxy(&m_paymentProvider));
   m_paymentProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&PaymentRequest::OnError, wrapWeakPersistent(this),
                 mojom::blink::PaymentErrorReason::UNKNOWN)));
-  m_paymentProvider->Init(
-      m_clientBinding.CreateInterfacePtrAndBind(),
-      mojo::WTFArray<mojom::blink::PaymentMethodDataPtr>::From(
-          validatedMethodData),
-      mojom::blink::PaymentDetails::From(details),
-      mojom::blink::PaymentOptions::From(m_options));
+
+  WTF::Vector<mojom::blink::PaymentMethodDataPtr> methods(
+      validatedMethodData.size());
+  for (size_t i = 0; i < validatedMethodData.size(); ++i) {
+    methods[i] = mojom::blink::PaymentMethodData::New();
+    methods[i]->supported_methods =
+        WTF::Vector<WTF::String>(validatedMethodData[i].supportedMethods);
+    methods[i]->stringified_data = validatedMethodData[i].stringifiedData;
+  }
+  m_paymentProvider->Init(m_clientBinding.CreateInterfacePtrAndBind(),
+                          std::move(methods),
+                          mojom::blink::PaymentDetails::From(details),
+                          mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnShippingAddressChange(
     mojom::blink::PaymentAddressPtr address) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
@@ skipping 156 matching lines @@
   m_completeTimer.stop();
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink