Add data parameter to payment details modifier.

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 17 matching lines @@
 #include "modules/payments/PaymentShippingOption.h"
 #include "modules/payments/PaymentsValidators.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/wtf_array.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashSet.h"
+#include <stddef.h>
 #include <utility>
 
 using payments::mojom::blink::ActivePaymentQueryResult;
 using payments::mojom::blink::PaymentAddressPtr;
 using payments::mojom::blink::PaymentCurrencyAmount;
 using payments::mojom::blink::PaymentCurrencyAmountPtr;
-using payments::mojom::blink::PaymentDetails;
-using payments::mojom::blink::PaymentDetailsModifier;
 using payments::mojom::blink::PaymentDetailsModifierPtr;
 using payments::mojom::blink::PaymentDetailsPtr;
-using payments::mojom::blink::PaymentDetailsPtr;
 using payments::mojom::blink::PaymentErrorReason;
-using payments::mojom::blink::PaymentItem;
 using payments::mojom::blink::PaymentItemPtr;
-using payments::mojom::blink::PaymentMethodData;
 using payments::mojom::blink::PaymentMethodDataPtr;
-using payments::mojom::blink::PaymentOptions;
 using payments::mojom::blink::PaymentOptionsPtr;
 using payments::mojom::blink::PaymentResponsePtr;
-using payments::mojom::blink::PaymentShippingOption;
 using payments::mojom::blink::PaymentShippingOptionPtr;
 using payments::mojom::blink::PaymentShippingType;
 
 namespace mojo {
 
 template <>
 struct TypeConverter<PaymentCurrencyAmountPtr, blink::PaymentCurrencyAmount> {
   static PaymentCurrencyAmountPtr Convert(
       const blink::PaymentCurrencyAmount& input) {
     PaymentCurrencyAmountPtr output = PaymentCurrencyAmount::New();
     output->currency = input.currency();
     output->value = input.value();
     if (input.hasCurrencySystem())
       output->currencySystem = input.currencySystem();
     return output;
   }
 };
 
 template <>
 struct TypeConverter<PaymentItemPtr, blink::PaymentItem> {
   static PaymentItemPtr Convert(const blink::PaymentItem& input) {
-    PaymentItemPtr output = PaymentItem::New();
+    PaymentItemPtr output = payments::mojom::blink::PaymentItem::New();
     output->label = input.label();
     output->amount = PaymentCurrencyAmount::From(input.amount());
     output->pending = input.pending();
     return output;
   }
 };
 
 template <>
 struct TypeConverter<PaymentShippingOptionPtr, blink::PaymentShippingOption> {
   static PaymentShippingOptionPtr Convert(
       const blink::PaymentShippingOption& input) {
-    PaymentShippingOptionPtr output = PaymentShippingOption::New();
+    PaymentShippingOptionPtr output =
+        payments::mojom::blink::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 = input.supportedMethods();
-
-    if (input.hasTotal())
-      output->total = PaymentItem::From(input.total());
-
-    if (input.hasAdditionalDisplayItems()) {
-      for (size_t i = 0; i < input.additionalDisplayItems().size(); ++i) {
-        output->additional_display_items.append(
-            PaymentItem::From(input.additionalDisplayItems()[i]));
-      }
-    }
-    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()) {
-      for (size_t i = 0; i < input.displayItems().size(); ++i) {
-        output->display_items.append(
-            PaymentItem::From(input.displayItems()[i]));
-      }
-    }
-
-    if (input.hasShippingOptions()) {
-      for (size_t i = 0; i < input.shippingOptions().size(); ++i) {
-        output->shipping_options.append(
-            PaymentShippingOption::From(input.shippingOptions()[i]));
-      }
-    }
-
-    if (input.hasModifiers()) {
-      for (size_t i = 0; i < input.modifiers().size(); ++i) {
-        output->modifiers.append(
-            PaymentDetailsModifier::From(input.modifiers()[i]));
-      }
-    }
-
-    if (input.hasError())
-      output->error = input.error();
-    else
-      output->error = emptyString();
-
-    return output;
-  }
-};
-
-template <>
 struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
   static PaymentOptionsPtr Convert(const blink::PaymentOptions& input) {
-    PaymentOptionsPtr output = PaymentOptions::New();
+    PaymentOptionsPtr output = payments::mojom::blink::PaymentOptions::New();
     output->request_payer_name = input.requestPayerName();
     output->request_payer_email = input.requestPayerEmail();
     output->request_payer_phone = input.requestPayerPhone();
     output->request_shipping = input.requestShipping();
 
     if (input.shippingType() == "delivery")
       output->shipping_type = PaymentShippingType::DELIVERY;
     else if (input.shippingType() == "pickup")
       output->shipping_type = PaymentShippingType::PICKUP;
     else
@@ skipping 63 matching lines @@
     return;
   }
 
   if (!PaymentsValidators::isValidAmountFormat(item.amount().value(),
                                                &errorMessage)) {
     exceptionState.throwTypeError(errorMessage);
     return;
   }
 }
 
-void validateDisplayItems(const HeapVector<PaymentItem>& items,
-                          ExceptionState& exceptionState) {
-  for (const auto& item : items) {
+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));
   }
 }
 
-// Returns false if |options| should be ignored, even if an exception was not
-// thrown. TODO(rouslan): Clear shipping options instead of ignoring them when
-// http://crbug.com/601193 is fixed.
-bool validateShippingOptions(const HeapVector<PaymentShippingOption>& options,
-                             ExceptionState& exceptionState) {
+// 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,
+    Vector<PaymentShippingOptionPtr>& output,
+    ExceptionState& exceptionState) {
   HashSet<String> uniqueIds;
-  for (const auto& option : options) {
+  for (const PaymentShippingOption& option : input) {
     if (!option.hasId() || option.id().isEmpty()) {
       exceptionState.throwTypeError("ShippingOption id required");
-      return false;
+      return;
     }
 
-    if (uniqueIds.contains(option.id()))
-      return false;
+    if (uniqueIds.contains(option.id())) {
+      // Clear |output| instead of throwing an exception.
+      output.clear();
+      return;
+    }
 
     uniqueIds.add(option.id());
 
     validateShippingOptionOrPaymentItem(option, exceptionState);
     if (exceptionState.hadException())
-      return false;
+      return;
+
+    output.append(payments::mojom::blink::PaymentShippingOption::From(option));
   }
-
-  return true;
 }
 
-void validatePaymentDetailsModifiers(
-    const HeapVector<PaymentDetailsModifier>& modifiers,
-    ExceptionState& exceptionState) {
-  if (modifiers.isEmpty()) {
-    exceptionState.throwTypeError(
-        "Must specify at least one payment details modifier");
+void validateAndConvertTotal(const PaymentItem& input,
+                             PaymentItemPtr& output,
+                             ExceptionState& exceptionState) {
+  validateShippingOptionOrPaymentItem(input, exceptionState);
+  if (exceptionState.hadException())
+    return;
+
+  if (input.amount().value()[0] == '-') {
+    exceptionState.throwTypeError("Total amount value should be non-negative");
     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;
-    }
-  }
+  output = payments::mojom::blink::PaymentItem::From(input);
 }
 
-// Returns false if the shipping options should be ignored without throwing an
-// exception.
-bool validatePaymentDetails(const PaymentDetails& details,
-                            ExceptionState& exceptionState) {
-  bool keepShippingOptions = true;
-  if (!details.hasTotal()) {
-    exceptionState.throwTypeError("Must specify total");
-    return keepShippingOptions;
-  }
-
-  validateShippingOptionOrPaymentItem(details.total(), exceptionState);
-  if (exceptionState.hadException())
-    return keepShippingOptions;
-
-  if (details.total().amount().value()[0] == '-') {
-    exceptionState.throwTypeError("Total amount value should be non-negative");
-    return keepShippingOptions;
-  }
-
-  if (details.hasDisplayItems()) {
-    validateDisplayItems(details.displayItems(), exceptionState);
-    if (exceptionState.hadException())
-      return keepShippingOptions;
-  }
-
-  if (details.hasShippingOptions()) {
-    keepShippingOptions =
-        validateShippingOptions(details.shippingOptions(), exceptionState);
-
-    if (exceptionState.hadException())
-      return keepShippingOptions;
-  }
-
-  if (details.hasModifiers()) {
-    validatePaymentDetailsModifiers(details.modifiers(), exceptionState);
-    if (exceptionState.hadException())
-      return keepShippingOptions;
-  }
-
-  String errorMessage;
-  if (!PaymentsValidators::isValidErrorMsgFormat(details.error(),
-                                                 &errorMessage)) {
-    exceptionState.throwTypeError(errorMessage);
-  }
-
-  return keepShippingOptions;
-}
-
-void maybeSetAndroidPayMethodData(
-    const ScriptValue& input,
-    payments::mojom::blink::PaymentMethodDataPtr& output,
-    ExceptionState& exceptionState) {
+void maybeSetAndroidPayMethodData(const ScriptValue& input,
+                                  PaymentMethodDataPtr& output,
+                                  ExceptionState& exceptionState) {
   AndroidPayMethodData androidPay;
   DummyExceptionStateForTesting dummyExceptionState;
   V8AndroidPayMethodData::toImpl(input.isolate(), input.v8Value(), androidPay,
                                  dummyExceptionState);
   if (dummyExceptionState.hadException())
     return;
 
   if (androidPay.hasEnvironment() && androidPay.environment() == "TEST")
     output->environment = payments::mojom::blink::AndroidPayEnvironment::TEST;
 
   output->merchant_name = androidPay.merchantName();
   output->merchant_id = androidPay.merchantId();
 
   if (androidPay.hasAllowedCardNetworks()) {
-    output->allowed_card_networks.resize(
-        androidPay.allowedCardNetworks().size());
-    size_t numberOfNetworks = 0;
-    for (size_t i = 0; i < androidPay.allowedCardNetworks().size(); ++i) {
-      for (size_t j = 0; j < arraysize(kAndroidPayNetwork); ++j) {
-        if (androidPay.allowedCardNetworks()[i] == kAndroidPayNetwork[j].name) {
-          output->allowed_card_networks[numberOfNetworks++] =
-              kAndroidPayNetwork[j].code;
+    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);
           break;
         }
       }
     }
-    output->allowed_card_networks.resize(numberOfNetworks);
   }
 
   if (androidPay.hasPaymentMethodTokenizationParameters()) {
     const blink::AndroidPayTokenization& tokenization =
         androidPay.paymentMethodTokenizationParameters();
     output->tokenization_type =
         payments::mojom::blink::AndroidPayTokenization::UNSPECIFIED;
     if (tokenization.hasTokenizationType()) {
-      for (size_t j = 0; j < arraysize(kAndroidPayTokenization); ++j) {
+      for (size_t i = 0; i < arraysize(kAndroidPayTokenization); ++i) {
         if (tokenization.tokenizationType() ==
-            kAndroidPayTokenization[j].name) {
-          output->tokenization_type = kAndroidPayTokenization[j].code;
+            kAndroidPayTokenization[i].name) {
+          output->tokenization_type = kAndroidPayTokenization[i].code;
           break;
         }
       }
     }
 
     if (tokenization.hasParameters()) {
       const Vector<String>& keys =
           tokenization.parameters().getPropertyNames(exceptionState);
       if (exceptionState.hadException())
         return;
-      output->parameters.resize(keys.size());
-      size_t numberOfParameters = 0;
       String value;
-      for (size_t i = 0; i < keys.size(); ++i) {
-        if (!DictionaryHelper::get(tokenization.parameters(), keys[i], value))
+      for (const String& key : keys) {
+        if (!DictionaryHelper::get(tokenization.parameters(), key, value))
           continue;
-        output->parameters[numberOfParameters] =
-            payments::mojom::blink::AndroidPayTokenizationParameter::New();
-        output->parameters[numberOfParameters]->key = keys[i];
-        output->parameters[numberOfParameters]->value = value;
-        ++numberOfParameters;
+        output->parameters.append(
+            payments::mojom::blink::AndroidPayTokenizationParameter::New());
+        output->parameters.back()->key = key;
+        output->parameters.back()->value = value;
       }
-      output->parameters.resize(numberOfParameters);
     }
   }
 }
 
+void stringifyAndParseMethodSpecificData(const ScriptValue& input,
+                                         PaymentMethodDataPtr& output,
+                                         ExceptionState& exceptionState) {
+  DCHECK(!input.isEmpty());
+  if (!input.v8Value()->IsObject() || input.v8Value()->IsArray()) {
+    exceptionState.throwTypeError("Data should be a JSON-serializable object");
+    return;
+  }
+
+  v8::Local<v8::String> value;
+  if (!v8::JSON::Stringify(input.context(), input.v8Value().As<v8::Object>())
+           .ToLocal(&value)) {
+    exceptionState.throwTypeError(
+        "Unable to parse payment method specific data");
+    return;
+  }
+
+  output->stringified_data =
+      v8StringToWebCoreString<String>(value, DoNotExternalize);
+  maybeSetAndroidPayMethodData(input, output, exceptionState);
+}
+
+void validateAndConvertPaymentDetailsModifiers(
+    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());
+    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,
+                                     exceptionState);
+      if (exceptionState.hadException())
+        return;
+    }
+
+    if (modifier.supportedMethods().isEmpty()) {
+      exceptionState.throwTypeError(
+          "Must specify at least one payment method identifier");
+      return;
+    }
+
+    output.back()->method_data =
+        payments::mojom::blink::PaymentMethodData::New();
+    output.back()->method_data->supported_methods = modifier.supportedMethods();
+
+    if (modifier.hasData() && !modifier.data().isEmpty()) {
+      stringifyAndParseMethodSpecificData(
+          modifier.data(), output.back()->method_data, exceptionState);
+    } else {
+      output.back()->method_data->stringified_data = "";
+    }
+  }
+}
+
+String getSelectedShippingOption(
+    const Vector<PaymentShippingOptionPtr>& shippingOptions) {
+  String result;
+  for (const PaymentShippingOptionPtr& shippingOption : shippingOptions) {
+    if (shippingOption->selected)
+      result = shippingOption->id;
+  }
+  return result;
+}
+
+void validateAndConvertPaymentDetails(const PaymentDetails& input,
+                                      bool requestShipping,
+                                      PaymentDetailsPtr& output,
+                                      String& shippingOptionOutput,
+                                      ExceptionState& exceptionState) {
+  if (!input.hasTotal()) {
+    exceptionState.throwTypeError("Must specify total");
+    return;
+  }
+
+  validateAndConvertTotal(input.total(), output->total, exceptionState);
+  if (exceptionState.hadException())
+    return;
+
+  if (input.hasDisplayItems()) {
+    validateAndConvertDisplayItems(input.displayItems(), output->display_items,
+                                   exceptionState);
+    if (exceptionState.hadException())
+      return;
+  }
+
+  if (input.hasShippingOptions() && requestShipping) {
+    validateAndConvertShippingOptions(input.shippingOptions(),
+                                      output->shipping_options, exceptionState);
+    if (exceptionState.hadException())
+      return;
+  }
+
+  shippingOptionOutput = getSelectedShippingOption(output->shipping_options);
+
+  if (input.hasModifiers()) {
+    validateAndConvertPaymentDetailsModifiers(
+        input.modifiers(), output->modifiers, exceptionState);
+    if (exceptionState.hadException())
+      return;
+  }
+
+  if (input.hasError() && !input.error().isNull()) {
+    String errorMessage;
+    if (!PaymentsValidators::isValidErrorMsgFormat(input.error(),
+                                                   &errorMessage)) {
+      exceptionState.throwTypeError(errorMessage);
+      return;
+    }
+    output->error = input.error();
+  } else {
+    output->error = "";
+  }
+}
+
 void validateAndConvertPaymentMethodData(
     const HeapVector<PaymentMethodData>& input,
     Vector<payments::mojom::blink::PaymentMethodDataPtr>& output,
     ExceptionState& exceptionState) {
   if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment method identifier");
     return;
   }
 
-  output.resize(input.size());
-  for (size_t i = 0; i < input.size(); ++i) {
-    const auto& paymentMethodData = input[i];
+  for (const PaymentMethodData paymentMethodData : input) {
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
-    String stringifiedData = "";
+    output.append(payments::mojom::blink::PaymentMethodData::New());
+    output.back()->supported_methods = paymentMethodData.supportedMethods();
+
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
-      if (!paymentMethodData.data().v8Value()->IsObject() ||
-          paymentMethodData.data().v8Value()->IsArray()) {
-        exceptionState.throwTypeError(
-            "Data should be a JSON-serializable object");
-        return;
-      }
-
-      v8::Local<v8::String> value;
-      if (!v8::JSON::Stringify(
-               paymentMethodData.data().context(),
-               paymentMethodData.data().v8Value().As<v8::Object>())
-               .ToLocal(&value)) {
-        exceptionState.throwTypeError(
-            "Unable to parse payment method specific data");
-        return;
-      }
-      stringifiedData =
-          v8StringToWebCoreString<String>(value, DoNotExternalize);
-    }
-
-    output[i] = payments::mojom::blink::PaymentMethodData::New();
-    output[i]->supported_methods = paymentMethodData.supportedMethods();
-    output[i]->stringified_data = stringifiedData;
-    maybeSetAndroidPayMethodData(paymentMethodData.data(), output[i],
-                                 exceptionState);
-    if (exceptionState.hadException())
-      return;
-  }
-}
-
-String getSelectedShippingOption(const PaymentDetails& details) {
-  String result;
-  if (!details.hasShippingOptions())
-    return result;
-
-  for (int i = details.shippingOptions().size() - 1; i >= 0; --i) {
-    if (details.shippingOptions()[i].hasSelected() &&
-        details.shippingOptions()[i].selected()) {
-      return details.shippingOptions()[i].id();
+      stringifyAndParseMethodSpecificData(paymentMethodData.data(),
+                                          output.back(), exceptionState);
+    } else {
+      output.back()->stringified_data = "";
     }
   }
-
-  return result;
 }
 
 String getValidShippingType(const String& shippingType) {
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
   };
-  for (size_t i = 0; i < WTF_ARRAY_LENGTH(validValues); i++) {
+  for (size_t i = 0; i < arraysize(validValues); i++) {
     if (shippingType == validValues[i])
       return shippingType;
   }
   return validValues[0];
 }
 
-PaymentDetailsPtr maybeKeepShippingOptions(PaymentDetailsPtr details,
-                                           bool keep) {
-  if (!keep)
-    details->shipping_options.resize(0);
-
-  return details;
-}
-
 bool allowedToUsePaymentRequest(const Frame* frame) {
   // To determine whether a Document object |document| is allowed to use the
   // feature indicated by attribute name |allowpaymentrequest|, run these steps:
 
   // 1. If |document| has no browsing context, then return false.
   if (!frame)
     return false;
 
   // 2. If |document|'s browsing context is a top-level browsing context, then
   // return true.
@@ skipping 139 matching lines @@
   V8PaymentDetails::toImpl(detailsScriptValue.isolate(),
                            detailsScriptValue.v8Value(), details,
                            exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
-  bool keepShippingOptions = validatePaymentDetails(details, exceptionState);
+  PaymentDetailsPtr validatedDetails =
+      payments::mojom::blink::PaymentDetails::New();
+  validateAndConvertPaymentDetails(details, m_options.requestShipping(),
+                                   validatedDetails, m_shippingOption,
+                                   exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
-  if (m_options.requestShipping()) {
-    if (keepShippingOptions)
-      m_shippingOption = getSelectedShippingOption(details);
-    else
-      m_shippingOption = String();
-  }
-
-  m_paymentProvider->UpdateWith(maybeKeepShippingOptions(
-      payments::mojom::blink::PaymentDetails::From(details),
-      keepShippingOptions));
+  m_paymentProvider->UpdateWith(std::move(validatedDetails));
 }
 
 void PaymentRequest::onUpdatePaymentDetailsFailure(const String& error) {
   if (m_showResolver)
     m_showResolver->reject(DOMException::create(AbortError, error));
   if (m_completeResolver)
     m_completeResolver->reject(DOMException::create(AbortError, error));
   clearResolversAndCloseMojoConnection();
 }
 
@@ skipping 36 matching lines @@
 
   if (!allowedToUsePaymentRequest(scriptState->domWindow()->frame())) {
     exceptionState.throwSecurityError(
         RuntimeEnabledFeatures::paymentRequestIFrameEnabled()
             ? "Must be in a top-level browsing context or an iframe needs to "
               "specify 'allowpaymentrequest' explicitly"
             : "Must be in a top-level browsing context");
     return;
   }
 
-  bool keepShippingOptions = validatePaymentDetails(details, exceptionState);
+  PaymentDetailsPtr validatedDetails =
+      payments::mojom::blink::PaymentDetails::New();
+  validateAndConvertPaymentDetails(details, m_options.requestShipping(),
+                                   validatedDetails, m_shippingOption,
+                                   exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (details.hasError()) {
     exceptionState.throwTypeError("Error message not allowed in constructor");
     return;
   }
 
-  if (m_options.requestShipping()) {
-    if (keepShippingOptions)
-      m_shippingOption = getSelectedShippingOption(details);
+  if (m_options.requestShipping())
     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),
                 PaymentErrorReason::UNKNOWN)));
   m_paymentProvider->Init(
       m_clientBinding.CreateInterfacePtrAndBind(),
-      std::move(validatedMethodData),
-      maybeKeepShippingOptions(
-          payments::mojom::blink::PaymentDetails::From(details),
-          keepShippingOptions && m_options.requestShipping()),
+      std::move(validatedMethodData), std::move(validatedDetails),
       payments::mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnShippingAddressChange(PaymentAddressPtr address) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
@@ skipping 21 matching lines @@
   m_shippingOption = shippingOptionId;
   PaymentRequestUpdateEvent* event =
       PaymentRequestUpdateEvent::create(EventTypeNames::shippingoptionchange);
   event->setTarget(this);
   event->setPaymentDetailsUpdater(this);
   bool success = getExecutionContext()->getEventQueue()->enqueueEvent(event);
   DCHECK(success);
   ALLOW_UNUSED_LOCAL(success);
 }
 
-void PaymentRequest::OnPaymentResponse(
-    payments::mojom::blink::PaymentResponsePtr response) {
+void PaymentRequest::OnPaymentResponse(PaymentResponsePtr response) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
   DCHECK(!m_completeTimer.isActive());
 
   if (m_options.requestShipping()) {
     if (!response->shipping_address || response->shipping_option.isEmpty()) {
       m_showResolver->reject(DOMException::create(SyntaxError));
       clearResolversAndCloseMojoConnection();
       return;
     }
@@ skipping 144 matching lines @@
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
   m_canMakeActivePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink