Revert of Overwrite the HeapVector of ShippingOptions for more clear code.

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 211 matching lines @@
 
 void validateDisplayItems(const HeapVector<PaymentItem>& items,
                           ExceptionState& exceptionState) {
   for (const auto& item : items) {
     validateShippingOptionOrPaymentItem(item, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 }
 
-void validateShippingOptions(HeapVector<PaymentShippingOption>& options,
+// 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) {
   HashSet<String> uniqueIds;
   for (const auto& option : options) {
     if (!option.hasId() || option.id().isEmpty()) {
       exceptionState.throwTypeError("ShippingOption id required");
-      return;
+      return false;
     }
 
-    if (uniqueIds.contains(option.id())) {
-      options.clear();
-      return;
-    }
+    if (uniqueIds.contains(option.id()))
+      return false;
 
     uniqueIds.add(option.id());
 
     validateShippingOptionOrPaymentItem(option, exceptionState);
     if (exceptionState.hadException())
-      return;
+      return false;
   }
+
+  return true;
 }
 
 void validatePaymentDetailsModifiers(
     const HeapVector<PaymentDetailsModifier>& modifiers,
     ExceptionState& exceptionState) {
   if (modifiers.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment details modifier");
     return;
   }
@@ skipping 28 matching lines @@
     }
 
     if (modifier.hasAdditionalDisplayItems()) {
       validateDisplayItems(modifier.additionalDisplayItems(), exceptionState);
       if (exceptionState.hadException())
         return;
     }
   }
 }
 
-void validatePaymentDetails(PaymentDetails& details,
+// 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;
+    return keepShippingOptions;
   }
 
   validateShippingOptionOrPaymentItem(details.total(), exceptionState);
   if (exceptionState.hadException())
-    return;
+    return keepShippingOptions;
 
   if (details.total().amount().value()[0] == '-') {
     exceptionState.throwTypeError("Total amount value should be non-negative");
-    return;
+    return keepShippingOptions;
   }
 
   if (details.hasDisplayItems()) {
     validateDisplayItems(details.displayItems(), exceptionState);
     if (exceptionState.hadException())
-      return;
+      return keepShippingOptions;
   }
 
   if (details.hasShippingOptions()) {
-    HeapVector<PaymentShippingOption> options = details.shippingOptions();
-    validateShippingOptions(options, exceptionState);
-    details.setShippingOptions(options);
+    keepShippingOptions =
+        validateShippingOptions(details.shippingOptions(), exceptionState);
 
     if (exceptionState.hadException())
-      return;
+      return keepShippingOptions;
   }
 
   if (details.hasModifiers()) {
     validatePaymentDetailsModifiers(details.modifiers(), exceptionState);
     if (exceptionState.hadException())
-      return;
+      return keepShippingOptions;
   }
 
   String errorMessage;
   if (!PaymentsValidators::isValidErrorMsgFormat(details.error(),
                                                  &errorMessage)) {
     exceptionState.throwTypeError(errorMessage);
   }
+
+  return keepShippingOptions;
 }
 
 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 58 matching lines @@
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
   };
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(validValues); i++) {
     if (shippingType == validValues[i])
       return shippingType;
   }
   return validValues[0];
 }
 
+mojom::blink::PaymentDetailsPtr maybeKeepShippingOptions(
+    mojom::blink::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 138 matching lines @@
   V8PaymentDetails::toImpl(detailsScriptValue.isolate(),
                            detailsScriptValue.v8Value(), details,
                            exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
-  validatePaymentDetails(details, exceptionState);
+  bool keepShippingOptions = validatePaymentDetails(details, exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
-  if (m_options.requestShipping())
-    m_shippingOption = getSelectedShippingOption(details);
+  if (m_options.requestShipping()) {
+    if (keepShippingOptions)
+      m_shippingOption = getSelectedShippingOption(details);
+    else
+      m_shippingOption = String();
+  }
 
-  m_paymentProvider->UpdateWith(mojom::blink::PaymentDetails::From(details));
+  m_paymentProvider->UpdateWith(maybeKeepShippingOptions(
+      mojom::blink::PaymentDetails::From(details), keepShippingOptions));
 }
 
 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 33 matching lines @@
     return;
   }
 
   if (!allowedToUsePaymentRequest(scriptState->domWindow()->frame())) {
     exceptionState.throwSecurityError(
         "Must be in a top-level browsing context or an iframe needs to specify "
         "'allowpaymentrequest' explicitly");
     return;
   }
 
-  PaymentDetails fixedDetails = details;
-  validatePaymentDetails(fixedDetails, exceptionState);
+  bool keepShippingOptions = validatePaymentDetails(details, exceptionState);
   if (exceptionState.hadException())
     return;
 
-  if (fixedDetails.hasError() && !fixedDetails.error().isEmpty()) {
+  if (details.hasError() && !details.error().isEmpty()) {
     exceptionState.throwTypeError("Error value should be empty");
     return;
   }
 
   if (m_options.requestShipping()) {
-    m_shippingOption = getSelectedShippingOption(fixedDetails);
+    if (keepShippingOptions)
+      m_shippingOption = getSelectedShippingOption(details);
     m_shippingType = getValidShippingType(m_options.shippingType());
-  } else {
-    fixedDetails.setShippingOptions(HeapVector<PaymentShippingOption>());
   }
 
   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(),
-                          ConvertPaymentMethodData(validatedMethodData),
-                          mojom::blink::PaymentDetails::From(fixedDetails),
-                          mojom::blink::PaymentOptions::From(m_options));
+  m_paymentProvider->Init(
+      m_clientBinding.CreateInterfacePtrAndBind(),
+      ConvertPaymentMethodData(validatedMethodData),
+      maybeKeepShippingOptions(
+          mojom::blink::PaymentDetails::From(details),
+          keepShippingOptions && m_options.requestShipping()),
+      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