Do not parse JSON in the browser.

third_party/WebKit/Source/modules/payments/PaymentRequest.cpp

Index: third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
diff --git a/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp b/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
index 6ce9aeb6f6529eb8772fc9e81a7a54c6b1885fca..cc687780a5727d05f16c3b05bdf8cfcf1e98fe58 100644
--- a/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
+++ b/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
@@ -8,6 +8,7 @@
 #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"
@@ -17,6 +18,8 @@
 #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"
@@ -166,22 +169,6 @@ struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
   }
 };
 
-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 {
@@ -349,17 +336,105 @@ bool validatePaymentDetails(const PaymentDetails& details,
   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");
@@ -387,8 +462,11 @@ void validateAndConvertPaymentMethodData(
       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]);
   }
 }
 
@@ -455,20 +533,6 @@ bool allowedToUsePaymentRequest(const Frame* frame) {
   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(
@@ -639,8 +703,8 @@ PaymentRequest::PaymentRequest(ScriptState* scriptState,
       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;
@@ -679,7 +743,7 @@ PaymentRequest::PaymentRequest(ScriptState* scriptState,
                 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()),