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/mojo/MojoHelper.h"
@@ skipping 139 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;
 
 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 maybeSetAndroidPayMethodata(
+void maybeSetAndroidPayMethodData(
     const ScriptValue& input,
     payments::mojom::blink::PaymentMethodDataPtr& output) {
   AndroidPayMethodData androidPay;
   TrackExceptionState exceptionState;
   V8AndroidPayMethodData::toImpl(input.isolate(), input.v8Value(), androidPay,
                                  exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (androidPay.hasEnvironment() && androidPay.environment() == "TEST")
@@ skipping 46 matching lines @@
             payments::mojom::blink::AndroidPayTokenizationParameter::New();
         output->parameters[numberOfParameters]->key = keys[i];
         output->parameters[numberOfParameters]->value = value;
         ++numberOfParameters;
       }
       output->parameters.resize(numberOfParameters);
     }
   }
 }
 
+void maybeSetBasicCardMethodData(
+    const ScriptValue& input,
+    payments::mojom::blink::PaymentMethodDataPtr& output) {
+  BasicCardRequest basicCard;
+  TrackExceptionState exceptionState;

[haraken, 2016/11/22 01:18:59]

It looks strange to use TrackExceptionState in production code, since it means
you're ignoring an exception.

[please use gerrit instead, 2016/11/22 03:10:55]

That's an excellent point. I am indeed ignoring the exception, because the
"input" is supposed to be specific to a payment app. The parsing of payment app
specific data should not throw exceptions, because it's up to the payment app to
decide what to do with this data. Eventually this structured data will reach the
app in the browser, (for example, Android Pay). If the data is not suitable for
the app, either PaymentRequest.show() promise is eventually rejected or
canMakeActivePayment() resolves with "false".

[haraken, 2016/11/22 04:26:03]

Yeah, but would it be better to pass in the ExceptionState from
validateAndConvertPaymentMethodData? If you want to ignore, you can just
explicitly call exceptionState.clear().

[please use gerrit instead, 2016/11/22 15:20:03]

Done. I'm deferring to your expertise on this subject, but it would be great to
hear an explanation of why you think this approach is best in this case.

+  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;
-    maybeSetAndroidPayMethodata(paymentMethodData.data(), output[i]);
+    maybeSetAndroidPayMethodData(paymentMethodData.data(), output[i]);
+    maybeSetBasicCardMethodData(paymentMethodData.data(), output[i]);
   }
 }
 
 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 481 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