Implement the new basic card specification.

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"
 #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/ExceptionCode.h"
 #include "core/events/Event.h"
 #include "core/events/EventQueue.h"
 #include "core/frame/FrameOwner.h"
 #include "core/html/HTMLIFrameElement.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"
 #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"
@@ skipping 77 matching lines @@
 
     return output;
   }
 };
 
 }  // namespace mojo
 
 namespace blink {
 namespace {
 
-using payments::mojom::blink::AndroidPayCardNetwork;
-using payments::mojom::blink::AndroidPayTokenization;
-
 // 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;
 
-const struct {
-  const AndroidPayCardNetwork code;
-  const char* name;
-} kAndroidPayNetwork[] = {{AndroidPayCardNetwork::AMEX, "AMEX"},
-                          {AndroidPayCardNetwork::DISCOVER, "DISCOVER"},
-                          {AndroidPayCardNetwork::MASTERCARD, "MASTERCARD"},
-                          {AndroidPayCardNetwork::VISA, "VISA"}};
-
-const struct {
-  const AndroidPayTokenization code;
-  const char* name;
-} kAndroidPayTokenization[] = {
-    {AndroidPayTokenization::GATEWAY_TOKEN, "GATEWAY_TOKEN"},
-    {AndroidPayTokenization::NETWORK_TOKEN, "NETWORK_TOKEN"}};
-
 // 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,
                                          ExceptionState& exceptionState) {
   if (!item.hasLabel() || item.label().isEmpty()) {
     exceptionState.throwTypeError("Item label required");
     return;
   }
 
@@ skipping 78 matching lines @@
     return;
 
   if (input.amount().value()[0] == '-') {
     exceptionState.throwTypeError("Total amount value should be non-negative");
     return;
   }
 
   output = payments::mojom::blink::PaymentItem::From(input);
 }
 
-void maybeSetAndroidPayMethodData(const ScriptValue& input,
-                                  PaymentMethodDataPtr& output,
-                                  ExceptionState& exceptionState) {
+// Parses Android Pay data to avoid parsing JSON in the browser.
+void setAndroidPayMethodData(const ScriptValue& input,
+                             PaymentMethodDataPtr& output,
+                             ExceptionState& exceptionState) {
   AndroidPayMethodData androidPay;
-  DummyExceptionStateForTesting dummyExceptionState;
   V8AndroidPayMethodData::toImpl(input.isolate(), input.v8Value(), androidPay,
-                                 dummyExceptionState);
-  if (dummyExceptionState.hadException())
+                                 exceptionState);
+  if (exceptionState.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();
 
   // 0 means the merchant did not specify or it was an invalid value
   output->min_google_play_services_version = 0;
   if (androidPay.hasMinGooglePlayServicesVersion()) {
     bool ok = false;
     int minGooglePlayServicesVersion =
         androidPay.minGooglePlayServicesVersion().toIntStrict(&ok);
     if (ok) {
       output->min_google_play_services_version = minGooglePlayServicesVersion;
     }
   }
 
   if (androidPay.hasAllowedCardNetworks()) {
+    using payments::mojom::blink::AndroidPayCardNetwork;
+
+    const struct {
+      const AndroidPayCardNetwork code;
+      const char* const name;
+    } androidPayNetwork[] = {{AndroidPayCardNetwork::AMEX, "AMEX"},
+                             {AndroidPayCardNetwork::DISCOVER, "DISCOVER"},
+                             {AndroidPayCardNetwork::MASTERCARD, "MASTERCARD"},
+                             {AndroidPayCardNetwork::VISA, "VISA"}};
+
     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);
+      for (size_t i = 0; i < arraysize(androidPayNetwork); ++i) {
+        if (allowedCardNetwork == androidPayNetwork[i].name) {
+          output->allowed_card_networks.append(androidPayNetwork[i].code);
           break;
         }
       }
     }
   }
 
   if (androidPay.hasPaymentMethodTokenizationParameters()) {
     const blink::AndroidPayTokenization& tokenization =
         androidPay.paymentMethodTokenizationParameters();
     output->tokenization_type =
         payments::mojom::blink::AndroidPayTokenization::UNSPECIFIED;
     if (tokenization.hasTokenizationType()) {
-      for (size_t i = 0; i < arraysize(kAndroidPayTokenization); ++i) {
-        if (tokenization.tokenizationType() ==
-            kAndroidPayTokenization[i].name) {
-          output->tokenization_type = kAndroidPayTokenization[i].code;
+      using payments::mojom::blink::AndroidPayTokenization;
+
+      const struct {
+        const AndroidPayTokenization code;
+        const char* const name;
+      } androidPayTokenization[] = {
+          {AndroidPayTokenization::GATEWAY_TOKEN, "GATEWAY_TOKEN"},
+          {AndroidPayTokenization::NETWORK_TOKEN, "NETWORK_TOKEN"}};
+
+      for (size_t i = 0; i < arraysize(androidPayTokenization); ++i) {
+        if (tokenization.tokenizationType() == androidPayTokenization[i].name) {
+          output->tokenization_type = androidPayTokenization[i].code;
           break;
         }
       }
     }
 
     if (tokenization.hasParameters()) {
       const Vector<String>& keys =
           tokenization.parameters().getPropertyNames(exceptionState);
       if (exceptionState.hadException())
         return;
       String value;
       for (const String& key : keys) {
         if (!DictionaryHelper::get(tokenization.parameters(), key, value))
           continue;
         output->parameters.append(
             payments::mojom::blink::AndroidPayTokenizationParameter::New());
         output->parameters.back()->key = key;
         output->parameters.back()->value = value;
       }
     }
   }
 }
 
-void stringifyAndParseMethodSpecificData(const ScriptValue& input,
+// Parses basic-card data to avoid parsing JSON in the browser.
+void setBasicCardMethodData(const ScriptValue& input,
+                            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;
+
+    const struct {
+      const BasicCardNetwork code;
+      const char* const name;
+    } basicCardNetworks[] = {{BasicCardNetwork::AMEX, "amex"},
+                             {BasicCardNetwork::DINERS, "diners"},
+                             {BasicCardNetwork::DISCOVER, "discover"},
+                             {BasicCardNetwork::JCB, "jcb"},
+                             {BasicCardNetwork::MASTERCARD, "mastercard"},
+                             {BasicCardNetwork::UNIONPAY, "unionpay"},
+                             {BasicCardNetwork::VISA, "visa"}};
+
+    for (const String& network : basicCard.supportedNetworks()) {
+      for (size_t i = 0; i < arraysize(basicCardNetworks); ++i) {
+        if (network == basicCardNetworks[i].name) {
+          output->supported_networks.append(basicCardNetworks[i].code);
+          break;
+        }
+      }
+    }
+  }
+
+  if (basicCard.hasSupportedTypes()) {
+    using payments::mojom::blink::BasicCardType;
+
+    const struct {
+      const BasicCardType code;
+      const char* const name;
+    } basicCardTypes[] = {{BasicCardType::CREDIT, "credit"},
+                          {BasicCardType::DEBIT, "debit"},
+                          {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.append(basicCardTypes[i].code);
+          break;
+        }
+      }
+    }
+  }
+}
+
+void stringifyAndParseMethodSpecificData(const Vector<String>& supportedMethods,
+                                         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);
+
+  if (supportedMethods.contains("https://android.com/pay")) {
+    setAndroidPayMethodData(input, output, exceptionState);
+    if (exceptionState.hadException())

[Marijn Kruisselbrink, 2017/01/05 22:38:03]

I recently came across Source/bindings/core/v8/ExceptionStatePlaceholder.h which
has an IGNORE_EXCEPTION thing, which you could use rather than passing the real
ExceptionState and clearing all exceptions that are thrown. But not sure if that
is any better (or worse) than what people used to use
DummyExceptionStateForTesting for...

[haraken, 2017/01/06 00:04:17]

I intentionally removed DummyExceptionStateForTesting because people have abused
it. ExceptionState must not be ignored unless you have a strong reason to do so.

Would you elaborate on why you want to ignore an exception here?

[Marijn Kruisselbrink, 2017/01/06 00:16:07]

I think the reason why exceptions are being ignored here has already been
sufficiently discussed earlier in this CL/thread?

My question was more that if using
TrackExceptionState/DummyExceptionStateForTesting (which seems to be mostly used
by production code to transform an exception into some other way of reporting
the error) is bad because it can be used to ignore exceptions, why isn't using
IGNORE_EXCEPTION just as bad? Should IGNORE_EXCEPTION also be
renamed/changed/discouraged? It's used almost a hundred times, almost none of
those in test code.

+      exceptionState.clearException();
+  }
+
+  if (RuntimeEnabledFeatures::paymentRequestBasicCardEnabled() &&
+      supportedMethods.contains("basic-card")) {
+    setBasicCardMethodData(input, output, exceptionState);
+    if (exceptionState.hadException())
+      exceptionState.clearException();
+  }
 }
 
 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;
@@ skipping 21 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.data(), output.back()->method_data, exceptionState);
+          modifier.supportedMethods(), 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) {
@@ skipping 67 matching lines @@
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
     output.append(payments::mojom::blink::PaymentMethodData::New());
     output.back()->supported_methods = paymentMethodData.supportedMethods();
 
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
-      stringifyAndParseMethodSpecificData(paymentMethodData.data(),
+      stringifyAndParseMethodSpecificData(paymentMethodData.supportedMethods(),
+                                          paymentMethodData.data(),
                                           output.back(), exceptionState);
     } else {
       output.back()->stringified_data = "";
     }
   }
 }
 
 String getValidShippingType(const String& shippingType) {
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
@@ skipping 449 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