Download web payment manifests.

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 <stddef.h>
 #include <utility>
 #include "bindings/core/v8/ConditionalFeatures.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/V8NativeAndroidPaymentAppManifest.h"
+#include "bindings/modules/v8/V8NativeAndroidPaymentAppManifestSection.h"
 #include "bindings/modules/v8/V8PaymentDetails.h"
 #include "core/EventTypeNames.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/events/EventQueue.h"
 #include "core/frame/FrameOwner.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/ConsoleTypes.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/NativeAndroidPaymentAppManifest.h"
+#include "modules/payments/NativeAndroidPaymentAppManifestSection.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 "platform/RuntimeEnabledFeatures.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashSet.h"
+#include "wtf/Optional.h"
 
-using payments::mojom::blink::CanMakePaymentQueryResult;
-using payments::mojom::blink::PaymentAddressPtr;
-using payments::mojom::blink::PaymentCurrencyAmount;
-using payments::mojom::blink::PaymentCurrencyAmountPtr;
-using payments::mojom::blink::PaymentDetailsModifierPtr;
-using payments::mojom::blink::PaymentDetailsPtr;
-using payments::mojom::blink::PaymentErrorReason;
-using payments::mojom::blink::PaymentItemPtr;
-using payments::mojom::blink::PaymentMethodDataPtr;
-using payments::mojom::blink::PaymentOptionsPtr;
-using payments::mojom::blink::PaymentResponsePtr;
-using payments::mojom::blink::PaymentShippingOptionPtr;
-using payments::mojom::blink::PaymentShippingType;
+namespace {
+
+using ::payments::mojom::blink::CanMakePaymentQueryResult;
+using ::payments::mojom::blink::NativeAndroidPaymentAppManifestSection;
+using ::payments::mojom::blink::NativeAndroidPaymentAppManifestSectionPtr;
+using ::payments::mojom::blink::PaymentAddressPtr;
+using ::payments::mojom::blink::PaymentCurrencyAmount;
+using ::payments::mojom::blink::PaymentCurrencyAmountPtr;
+using ::payments::mojom::blink::PaymentDetailsModifierPtr;
+using ::payments::mojom::blink::PaymentDetailsPtr;
+using ::payments::mojom::blink::PaymentErrorReason;
+using ::payments::mojom::blink::PaymentItemPtr;
+using ::payments::mojom::blink::PaymentMethodDataPtr;
+using ::payments::mojom::blink::PaymentOptionsPtr;
+using ::payments::mojom::blink::PaymentResponsePtr;
+using ::payments::mojom::blink::PaymentShippingOptionPtr;
+using ::payments::mojom::blink::PaymentShippingType;
+
+}  // namespace
 
 namespace mojo {
 
 template <>
+struct TypeConverter<NativeAndroidPaymentAppManifestSectionPtr,
+                     blink::NativeAndroidPaymentAppManifestSection> {
+  static NativeAndroidPaymentAppManifestSectionPtr Convert(
+      const blink::NativeAndroidPaymentAppManifestSection& input) {
+    NativeAndroidPaymentAppManifestSectionPtr output =
+        NativeAndroidPaymentAppManifestSection::New();
+    output->package_name = input.package();
+    output->version = input.hasVersion() ? input.version() : 0;
+    if (input.hasSha256_cert_fingerprints())
+      output->sha256_cert_fingerprints = input.sha256_cert_fingerprints();
+    return output;
+  }
+};
+
+template <>
 struct TypeConverter<PaymentCurrencyAmountPtr, blink::PaymentCurrencyAmount> {
   static PaymentCurrencyAmountPtr Convert(
       const blink::PaymentCurrencyAmount& input) {
     PaymentCurrencyAmountPtr output = PaymentCurrencyAmount::New();
     output->currency = input.currency();
     output->value = input.value();
     output->currency_system = input.currencySystem();
     return output;
   }
 };
@@ skipping 973 matching lines @@
       break;
     case CanMakePaymentQueryResult::QUERY_QUOTA_EXCEEDED:
       m_canMakePaymentResolver->reject(
           DOMException::create(QuotaExceededError, "Query quota exceeded"));
       break;
   }
 
   m_canMakePaymentResolver.clear();
 }
 
+void PaymentRequest::ParsePaymentManifest(
+    const String& content,
+    const ParsePaymentManifestCallback& callback) {
+  Optional<Vector<NativeAndroidPaymentAppManifestSectionPtr>> result;
+
+  ScriptState* state = ScriptState::forMainWorld(frame());

[Marijn Kruisselbrink, 2017/02/23 20:07:06]

I don't think using ScriptState::forMainWorld (or really any script state) here
is okay. Parsing JSON this way can have observable side effects in the world
you're passing it, and certainly can return different results depending on the
state of that world. Probably what you want to do is not involve any v8 code at
all, and instead use blink::parseJSON (from Source/platform/json/JSONParser.h)
to parse it?

+  if (!state->contextIsValid()) {
+    callback.Run(std::move(result));
+    return;
+  }
+
+  ScriptState::Scope scope(state);
+  ExceptionState exceptionState(state->isolate(),
+                                ExceptionState::ConstructionContext,
+                                "NativeAndroidPaymentAppManifest");
+  v8::Local<v8::Value> input =
+      fromJSONString(state->isolate(), content, exceptionState);
+  if (exceptionState.hadException()) {
+    callback.Run(std::move(result));
+    return;
+  }
+
+  NativeAndroidPaymentAppManifest manifest;
+  V8NativeAndroidPaymentAppManifest::toImpl(state->isolate(), input, manifest,
+                                            exceptionState);
+  if (exceptionState.hadException()) {
+    callback.Run(std::move(result));
+    return;
+  }
+
+  if (manifest.hasAndroid() && !manifest.android().isEmpty()) {
+    result = Vector<NativeAndroidPaymentAppManifestSectionPtr>();
+    for (const auto& section : manifest.android()) {
+      result->push_back(
+          payments::mojom::blink::NativeAndroidPaymentAppManifestSection::From(
+              section));
+    }
+  }
+
+  callback.Run(std::move(result));
+}
+
 void PaymentRequest::onCompleteTimeout(TimerBase*) {
   m_paymentProvider->Complete(payments::mojom::blink::PaymentComplete(Fail));
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::clearResolversAndCloseMojoConnection() {
   m_completeTimer.stop();
   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