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 140 matching lines @@
   }
 };
 
 }  // namespace mojo
 
 namespace blink {
 namespace {
 
 using payments::mojom::blink::AndroidPayCardNetwork;
 using payments::mojom::blink::AndroidPayTokenization;
+using payments::mojom::blink::BasicCardNetwork;
+using payments::mojom::blink::BasicCardType;
 
 // 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;
 
+static const char* androidPayMethodName = "https://android.com/pay";
+static const char* basicCardMethodName = "basic-card";
+
 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"}};
 
+const struct {
+  const BasicCardNetwork code;
+  const char* name;
+} kBasicCardNetworks[] = {{BasicCardNetwork::AMEX, "amex"},
+                          {BasicCardNetwork::DINERS, "diners"},
+                          {BasicCardNetwork::DISCOVER, "discover"},
+                          {BasicCardNetwork::JCB, "jcb"},
+                          {BasicCardNetwork::MASTERCARD, "mastercard"},
+                          {BasicCardNetwork::UNIONPAY, "unionpay"},
+                          {BasicCardNetwork::VISA, "visa"}};
+
+const struct {
+  const BasicCardType code;
+  const char* name;
+} kBasicCardTypes[] = {{BasicCardType::CREDIT, "credit"},
+                       {BasicCardType::DEBIT, "debit"},
+                       {BasicCardType::PREPAID, "prepaid"}};
+
 // 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 138 matching lines @@
 
   String errorMessage;
   if (!PaymentsValidators::isValidErrorMsgFormat(details.error(),
                                                  &errorMessage)) {
     exceptionState.throwTypeError(errorMessage);
   }
 
   return keepShippingOptions;
 }
 
-void maybeSetAndroidPayMethodData(
+// Parses Android Pay data to avoid parsing JSON in the browser.
+void setAndroidPayMethodData(
     const ScriptValue& input,
     payments::mojom::blink::PaymentMethodDataPtr& output,
     ExceptionState& exceptionState) {
   AndroidPayMethodData androidPay;
-  TrackExceptionState trackExceptionState;
   V8AndroidPayMethodData::toImpl(input.isolate(), input.v8Value(), androidPay,
-                                 trackExceptionState);
-  if (trackExceptionState.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();
 
   if (androidPay.hasAllowedCardNetworks()) {
     output->allowed_card_networks.resize(
@@ skipping 41 matching lines @@
             payments::mojom::blink::AndroidPayTokenizationParameter::New();
         output->parameters[numberOfParameters]->key = keys[i];
         output->parameters[numberOfParameters]->value = value;
         ++numberOfParameters;
       }
       output->parameters.resize(numberOfParameters);
     }
   }
 }
 
+// Parses basic-card data to avoid parsing JSON in the browser.
+void setBasicCardMethodData(
+    const ScriptValue& input,
+    payments::mojom::blink::PaymentMethodDataPtr& output,
+    ExceptionState& exceptionState) {
+  BasicCardRequest basicCard;
+  V8BasicCardRequest::toImpl(input.isolate(), input.v8Value(), basicCard,
+                             exceptionState);
+  if (exceptionState.hadException())
+    return;
+
+  if (basicCard.hasSupportedNetworks()) {
+    output->supported_networks.resize(basicCard.supportedNetworks().size());
+    size_t numberOfNetworks = 0;
+    for (size_t i = 0; i < basicCard.supportedNetworks().size(); ++i) {
+      for (size_t j = 0; j < arraysize(kBasicCardNetworks); ++j) {
+        if (basicCard.supportedNetworks()[i] == kBasicCardNetworks[j].name) {
+          output->supported_networks[numberOfNetworks++] =
+              kBasicCardNetworks[j].code;
+          break;
+        }
+      }
+    }
+    output->supported_networks.resize(numberOfNetworks);
+  }
+
+  if (basicCard.hasSupportedTypes()) {
+    output->supported_types.resize(basicCard.supportedTypes().size());
+    size_t numberOfTypes = 0;
+    for (size_t i = 0; i < basicCard.supportedTypes().size(); ++i) {
+      for (size_t j = 0; j < arraysize(kBasicCardTypes); ++j) {
+        if (basicCard.supportedTypes()[i] == kBasicCardTypes[j].name) {
+          output->supported_types[numberOfTypes++] = kBasicCardTypes[j].code;
+          break;
+        }
+      }
+    }
+    output->supported_types.resize(numberOfTypes);
+  }
+}
+
 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;
   }
 
@@ skipping 24 matching lines @@
             "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;
+
+    if (paymentMethodData.supportedMethods().contains(androidPayMethodName)) {
+      setAndroidPayMethodData(paymentMethodData.data(), output[i],
+                              exceptionState);
+      if (exceptionState.hadException())

[Marijn Kruisselbrink, 2016/11/29 21:09:53]

So after this change the PaymentRequest constructor will throw exceptions if
invalid data is passed for the given supportedMethods? That doesn't seem to be
something that's currently in the spec. If that's actually the desired behavior
it's probably a good idea to actually get that written in the PaymentRequest
constructor definition somewhere
Insert a step that calls out to some "payment method specific validation steps"
or something, where the basic card spec can then specify those steps? Not sure
how to best phrase that. Also not clear to me what the desired behavior is with
multiple payment methods in one PaymentMethodData. Should the data be valid for
all specified methods? Or for at least one? There seem to be many possibly valid
choices here, and without actually having this written down somewhere it seems
likely that browsers might make different choices.

At least the previous behavior of ignoring exceptions when the data doesn't
match the methods matched what is currently specified.

+        return;
+    }
+
+    if (RuntimeEnabledFeatures::paymentRequestBasicCardEnabled() &&
+        paymentMethodData.supportedMethods().contains(basicCardMethodName)) {
+      setBasicCardMethodData(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() &&
@@ skipping 483 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