Relax card type handling.

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/ConditionalFeatures.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"
 #include "bindings/modules/v8/V8AndroidPayMethodData.h"
 #include "bindings/modules/v8/V8BasicCardRequest.h"
 #include "bindings/modules/v8/V8PaymentDetails.h"
 #include "core/EventTypeNames.h"
 #include "core/dom/DOMException.h"
+#include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/events/EventQueue.h"
 #include "core/frame/FrameOwner.h"
 #include "core/html/HTMLIFrameElement.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/ConsoleTypes.h"
 #include "modules/EventTargetModulesNames.h"
 #include "modules/payments/AndroidPayMethodData.h"
 #include "modules/payments/AndroidPayTokenization.h"
 #include "modules/payments/BasicCardRequest.h"
 #include "modules/payments/HTMLIFrameElementPayments.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"
@@ skipping 273 matching lines @@
             payments::mojom::blink::AndroidPayTokenizationParameter::New());
         output->parameters.back()->key = key;
         output->parameters.back()->value = value;
       }
     }
   }
 }
 
 // Parses basic-card data to avoid parsing JSON in the browser.
 void setBasicCardMethodData(const ScriptValue& input,
+                            Document& document,
                             PaymentMethodDataPtr& output,
                             ExceptionState& exceptionState) {
   BasicCardRequest basicCard;
   V8BasicCardRequest::toImpl(input.isolate(), input.v8Value(), basicCard,
                              exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (basicCard.hasSupportedNetworks()) {
     using payments::mojom::blink::BasicCardNetwork;
@@ skipping 31 matching lines @@
                           {BasicCardType::PREPAID, "prepaid"}};
 
     for (const String& type : basicCard.supportedTypes()) {
       for (size_t i = 0; i < arraysize(basicCardTypes); ++i) {
         if (type == basicCardTypes[i].name) {
           output->supported_types.push_back(basicCardTypes[i].code);
           break;
         }
       }
     }
+
+    if (output->supported_types.size() != arraysize(basicCardTypes)) {
+      document.addConsoleMessage(ConsoleMessage::create(
+          JSMessageSource, WarningMessageLevel,
+          "Cannot yet distinguish credit, debit, and prepaid cards."));
+    }
   }
 }
 
 void stringifyAndParseMethodSpecificData(const Vector<String>& supportedMethods,
                                          const ScriptValue& input,
+                                         Document& document,
                                          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);
 
   // Serialize payment method specific data to be sent to the payment apps. The
   // payment apps are responsible for validating and processing their method
   // data asynchronously. Do not throw exceptions here.
   if (supportedMethods.contains("https://android.com/pay")) {
     setAndroidPayMethodData(input, output, exceptionState);
     if (exceptionState.hadException())
       exceptionState.clearException();
   }
   if (RuntimeEnabledFeatures::paymentRequestBasicCardEnabled() &&
       supportedMethods.contains("basic-card")) {
-    setBasicCardMethodData(input, output, exceptionState);
+    setBasicCardMethodData(input, document, output, exceptionState);
     if (exceptionState.hadException())
       exceptionState.clearException();
   }
 }
 
 void validateAndConvertPaymentDetailsModifiers(
     const HeapVector<PaymentDetailsModifier>& input,
+    Document& document,
     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.push_back(payments::mojom::blink::PaymentDetailsModifier::New());
@@ skipping 17 matching lines @@
           "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.supportedMethods(), modifier.data(),
+          modifier.supportedMethods(), modifier.data(), document,
           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,
+                                      Document& document,
                                       PaymentDetailsPtr& output,
                                       String& shippingOptionOutput,
                                       ExceptionState& exceptionState) {
   if (!input.hasTotal()) {
     exceptionState.throwTypeError("Must specify total");
     return;
   }
 
   validateAndConvertTotal(input.total(), output->total, exceptionState);
   if (exceptionState.hadException())
@@ skipping 10 matching lines @@
     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);
+        input.modifiers(), document, 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,
+    Document& document,
     Vector<payments::mojom::blink::PaymentMethodDataPtr>& output,
     ExceptionState& exceptionState) {
   if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment method identifier");
     return;
   }
 
   for (const PaymentMethodData paymentMethodData : input) {
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
     output.push_back(payments::mojom::blink::PaymentMethodData::New());
     output.back()->supported_methods = paymentMethodData.supportedMethods();
 
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
       stringifyAndParseMethodSpecificData(paymentMethodData.supportedMethods(),
-                                          paymentMethodData.data(),
+                                          paymentMethodData.data(), document,
                                           output.back(), exceptionState);
     } else {
       output.back()->stringified_data = "";
     }
   }
 }
 
 String getValidShippingType(const String& shippingType) {
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
@@ skipping 192 matching lines @@
                            exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
   PaymentDetailsPtr validatedDetails =
       payments::mojom::blink::PaymentDetails::New();
-  validateAndConvertPaymentDetails(details, m_options.requestShipping(),
-                                   validatedDetails, m_shippingOption,
-                                   exceptionState);
+  validateAndConvertPaymentDetails(
+      details, m_options.requestShipping(),
+      *detailsScriptValue.getScriptState()->domWindow()->document(),
+      validatedDetails, m_shippingOption, exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
   m_paymentProvider->UpdateWith(std::move(validatedDetails));
 }
 
@@ skipping 27 matching lines @@
                                const PaymentOptions& options,
                                ExceptionState& exceptionState)
     : ContextLifecycleObserver(&document),
       m_options(options),
       m_clientBinding(this),
       m_completeTimer(
           TaskRunnerHelper::get(TaskType::MiscPlatformAPI, document.frame()),
           this,
           &PaymentRequest::onCompleteTimeout) {
   Vector<payments::mojom::blink::PaymentMethodDataPtr> validatedMethodData;
-  validateAndConvertPaymentMethodData(methodData, validatedMethodData,
+  validateAndConvertPaymentMethodData(methodData, document, validatedMethodData,
                                       exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (!document.isSecureContext()) {
     exceptionState.throwSecurityError("Must be in a secure context");
     return;
   }
 
   if (!allowedToUsePaymentRequest(document.frame())) {
     exceptionState.throwSecurityError(
         "Must be in a top-level browsing context or an iframe needs to specify "
         "'allowpaymentrequest' explicitly");
     return;
   }
 
   PaymentDetailsPtr validatedDetails =
       payments::mojom::blink::PaymentDetails::New();
   validateAndConvertPaymentDetails(details, m_options.requestShipping(),
-                                   validatedDetails, m_shippingOption,
+                                   document, validatedDetails, m_shippingOption,
                                    exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (details.hasError()) {
     exceptionState.throwTypeError("Error message not allowed in constructor");
     return;
   }
 
   if (m_options.requestShipping())
@@ skipping 206 matching lines @@
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
   m_canMakePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink