Do not parse JSON in the browser.

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/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/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 129 matching lines @@
       output->shipping_type = PaymentShippingType::DELIVERY;
     else if (input.shippingType() == "pickup")
       output->shipping_type = PaymentShippingType::PICKUP;
     else
       output->shipping_type = PaymentShippingType::SHIPPING;
 
     return output;
   }
 };
 
-template <>
-struct TypeConverter<WTFArray<PaymentMethodDataPtr>,
-                     WTF::Vector<blink::PaymentRequest::MethodData>> {
-  static WTFArray<PaymentMethodDataPtr> Convert(
-      const WTF::Vector<blink::PaymentRequest::MethodData>& input) {
-    WTFArray<PaymentMethodDataPtr> output(input.size());
-    for (size_t i = 0; i < input.size(); ++i) {
-      output[i] = PaymentMethodData::New();
-      output[i]->supported_methods =
-          WTF::Vector<WTF::String>(input[i].supportedMethods);
-      output[i]->stringified_data = input[i].stringifiedData;
-    }
-    return output;
-  }
-};
-
 }  // namespace mojo
 
 namespace blink {
 namespace {
 
 // 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;
 
 // Validates ShippingOption or PaymentItem, which happen to have identical
@@ skipping 147 matching lines @@
 
   String errorMessage;
   if (!PaymentsValidators::isValidErrorMsgFormat(details.error(),
                                                  &errorMessage)) {
     exceptionState.throwTypeError(errorMessage);
   }
 
   return keepShippingOptions;
 }
 
+void maybeSetAndroidPayMethodata(
+    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")
+    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(
+        androidPay.allowedCardNetworks().size());
+    for (size_t i = 0; i < androidPay.allowedCardNetworks().size(); ++i) {
+      const String& network = androidPay.allowedCardNetworks()[i];
+      if (network == "AMEX") {
+        output->allowed_card_networks[i] =
+            payments::mojom::blink::AndroidPayCardNetwork::AMEX;
+      } else if (network == "DISCOVER") {
+        output->allowed_card_networks[i] =
+            payments::mojom::blink::AndroidPayCardNetwork::DISCOVER;
+      } else if (network == "MASTERCARD") {
+        output->allowed_card_networks[i] =
+            payments::mojom::blink::AndroidPayCardNetwork::MASTERCARD;
+      } else if (network == "VISA") {
+        output->allowed_card_networks[i] =
+            payments::mojom::blink::AndroidPayCardNetwork::VISA;
+      } else {
+        output->allowed_card_networks[i] =
+            payments::mojom::blink::AndroidPayCardNetwork::UNKNOWN;
+      }
+    }
+  }
+
+  if (androidPay.hasPaymentMethodTokenizationParameters()) {
+    const AndroidPayTokenization& tokenization =
+        androidPay.paymentMethodTokenizationParameters();
+    if (tokenization.hasTokenizationType()) {
+      if (tokenization.tokenizationType() == "GATEWAY_TOKEN") {
+        output->tokenization_type =
+            payments::mojom::blink::AndroidPayTokenization::GATEWAY_TOKEN;
+      } else if (tokenization.tokenizationType() == "NETWORK_TOKEN") {
+        output->tokenization_type =
+            payments::mojom::blink::AndroidPayTokenization::NETWORK_TOKEN;
+      } else {
+        output->tokenization_type =
+            payments::mojom::blink::AndroidPayTokenization::UNSPECIFIED;
+      }
+    }
+
+    if (tokenization.hasParameters() &&
+        tokenization.parameters().v8Value()->IsObject() &&
+        !tokenization.parameters().v8Value()->IsArray()) {
+      const ScriptValue& parameters = tokenization.parameters();

[Marijn Kruisselbrink, 2016/11/16 19:09:13]

I mentioned that record<DOMString, DOMString> or something like that is probably
the correct type for this "parameters" thing in webidl, rather than object as it
is now. But as you pointed out record isn't supported yet by our bindings.

But thinking about this a bit more, our bindings do support a non-standard
"Dictionary" type (which is currently used by Headers, a class in fetch) which
is very similar (and one of the reasons webidl now has a record type). So I
think you could make this code a bit simpler by using Dictionary in your idl.
This whole loop then would just be something like:

Vector<String> keys;
parameters.getPropertyNames(keys);
out->parameters.resize(keys.size());
for (size_t i = 0; i < keys.size(); ++i) {
  String value;
  if (!DictionaryHelper::get(parameters, keys[i], value))
    continue;
  out->parameters[i]->key = keys[i];
  out->parameters[i]->value = value;
}

(btw, is it intentional that invalid values leave gaps in output->parameters?)

[please use gerrit instead, 2016/11/16 20:23:23]

Thank you. Dictionary was exactly what I needed.

I was leaving gaps in the list intentionally. However, upon further reflection,
I found a cleaner way to avoid the gaps.

+      v8::Local<v8::Array> keys(
+          parameters.v8Value().As<v8::Object>()->GetOwnPropertyNames());
+      output->parameters.resize(keys->Length());
+      for (uint32_t i = 0; i < keys->Length(); ++i) {
+        v8::Local<v8::Value> key(keys->Get(i));
+        if (key->IsString()) {
+          v8::TryCatch tryCatch(parameters.isolate());
+          v8::Local<v8::Value> value =
+              parameters.v8Value().As<v8::Object>()->Get(key);
+          if (!tryCatch.HasCaught() && value->IsString()) {
+            output->parameters[i] =
+                payments::mojom::blink::AndroidPayTokenizationParameter::New();
+
+            v8::String::Utf8Value utf8Key(key);
+            output->parameters[i]->key = String(*utf8Key, utf8Key.length());
+
+            v8::String::Utf8Value utf8Value(value);
+            output->parameters[i]->value =
+                String(*utf8Value, utf8Value.length());
+          }
+        }
+      }
+    }
+  }
+}
+
 void validateAndConvertPaymentMethodData(
-    const HeapVector<PaymentMethodData>& paymentMethodDataVector,
-    Vector<PaymentRequest::MethodData>* methodData,
+    const HeapVector<PaymentMethodData>& input,
+    Vector<payments::mojom::blink::PaymentMethodDataPtr>& output,
     ExceptionState& exceptionState) {
-  if (paymentMethodDataVector.isEmpty()) {
+  if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment method identifier");
     return;
   }
 
-  for (const auto& paymentMethodData : paymentMethodDataVector) {
+  output.resize(input.size());
+  for (size_t i = 0; i < input.size(); ++i) {
+    const auto& paymentMethodData = input[i];
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
     String stringifiedData = "";
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
       if (!paymentMethodData.data().v8Value()->IsObject() ||
           paymentMethodData.data().v8Value()->IsArray()) {
         exceptionState.throwTypeError(
             "Data should be a JSON-serializable object");
         return;
       }
 
       v8::Local<v8::String> value;
       if (!v8::JSON::Stringify(
                paymentMethodData.data().context(),
                paymentMethodData.data().v8Value().As<v8::Object>())
                .ToLocal(&value)) {
         exceptionState.throwTypeError(
             "Unable to parse payment method specific data");
         return;
       }
       stringifiedData =
           v8StringToWebCoreString<String>(value, DoNotExternalize);
     }
-    methodData->append(PaymentRequest::MethodData(
-        paymentMethodData.supportedMethods(), stringifiedData));
+
+    output[i] = payments::mojom::blink::PaymentMethodData::New();
+    output[i]->supported_methods = paymentMethodData.supportedMethods();
+    output[i]->stringified_data = stringifiedData;
+    maybeSetAndroidPayMethodata(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 46 matching lines @@
   if (ownerElement && isHTMLIFrameElement(ownerElement)) {
     HTMLIFrameElement* iframe = toHTMLIFrameElement(ownerElement);
     if (HTMLIFrameElementPayments::from(*iframe).allowPaymentRequest(*iframe))
       return allowedToUsePaymentRequest(frame->tree().parent());
   }
 
   // 4. Return false.
   return false;
 }
 
-WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr>
-ConvertPaymentMethodData(
-    const Vector<PaymentRequest::MethodData>& blinkMethods) {
-  WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr> mojoMethods(
-      blinkMethods.size());
-  for (size_t i = 0; i < blinkMethods.size(); ++i) {
-    mojoMethods[i] = payments::mojom::blink::PaymentMethodData::New();
-    mojoMethods[i]->supported_methods =
-        WTF::Vector<WTF::String>(blinkMethods[i].supportedMethods);
-    mojoMethods[i]->stringified_data = blinkMethods[i].stringifiedData;
-  }
-  return mojoMethods;
-}
-
 }  // namespace
 
 PaymentRequest* PaymentRequest::create(
     ScriptState* scriptState,
     const HeapVector<PaymentMethodData>& methodData,
     const PaymentDetails& details,
     ExceptionState& exceptionState) {
   return new PaymentRequest(scriptState, methodData, details, PaymentOptions(),
                             exceptionState);
 }
@@ skipping 150 matching lines @@
 PaymentRequest::PaymentRequest(ScriptState* scriptState,
                                const HeapVector<PaymentMethodData>& methodData,
                                const PaymentDetails& details,
                                const PaymentOptions& options,
                                ExceptionState& exceptionState)
     : ContextLifecycleObserver(scriptState->getExecutionContext()),
       ActiveScriptWrappable(this),
       m_options(options),
       m_clientBinding(this),
       m_completeTimer(this, &PaymentRequest::onCompleteTimeout) {
-  Vector<MethodData> validatedMethodData;
-  validateAndConvertPaymentMethodData(methodData, &validatedMethodData,
+  Vector<payments::mojom::blink::PaymentMethodDataPtr> validatedMethodData;
+  validateAndConvertPaymentMethodData(methodData, validatedMethodData,
                                       exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (!scriptState->getExecutionContext()->isSecureContext()) {
     exceptionState.throwSecurityError("Must be in a secure context");
     return;
   }
 
   if (!allowedToUsePaymentRequest(scriptState->domWindow()->frame())) {
@@ skipping 18 matching lines @@
     m_shippingType = getValidShippingType(m_options.shippingType());
   }
 
   scriptState->domWindow()->frame()->interfaceProvider()->getInterface(
       mojo::GetProxy(&m_paymentProvider));
   m_paymentProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&PaymentRequest::OnError, wrapWeakPersistent(this),
                 payments::mojom::blink::PaymentErrorReason::UNKNOWN)));
   m_paymentProvider->Init(
       m_clientBinding.CreateInterfacePtrAndBind(),
-      ConvertPaymentMethodData(validatedMethodData),
+      std::move(validatedMethodData),
       maybeKeepShippingOptions(
           payments::mojom::blink::PaymentDetails::From(details),
           keepShippingOptions && m_options.requestShipping()),
       payments::mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
@@ skipping 165 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