Use ExecutionContext instead of Document in PaymentRequest constructor.

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/V8PaymentDetails.h"
 #include "core/EventTypeNames.h"
 #include "core/dom/DOMException.h"
@@ skipping 17 matching lines @@
 #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 <stddef.h>
-#include <utility>
 
 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;
@@ skipping 253 matching lines @@
             payments::mojom::blink::AndroidPayTokenizationParameter::New());
         output->parameters.back()->key = key;
         output->parameters.back()->value = value;
       }
     }
   }
 }
 
 // Parses basic-card data to avoid parsing JSON in the browser.
 void setBasicCardMethodData(const ScriptValue& input,
-                            Document& document,
                             PaymentMethodDataPtr& output,
+                            ExecutionContext& executionContext,
                             ExceptionState& exceptionState) {
   BasicCardRequest basicCard;
   V8BasicCardRequest::toImpl(input.isolate(), input.v8Value(), basicCard,
                              exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (basicCard.hasSupportedNetworks()) {
     using payments::mojom::blink::BasicCardNetwork;
 
@@ skipping 32 matching lines @@
     for (const String& type : basicCard.supportedTypes()) {
       for (size_t i = 0; i < arraysize(basicCardTypes); ++i) {
         if (type == basicCardTypes[i].name) {
           output->supported_types.push_back(basicCardTypes[i].code);
           break;
         }
       }
     }
 
     if (output->supported_types.size() != arraysize(basicCardTypes)) {
-      document.addConsoleMessage(ConsoleMessage::create(
+      executionContext.addConsoleMessage(ConsoleMessage::create(
           JSMessageSource, WarningMessageLevel,
           "Cannot yet distinguish credit, debit, and prepaid cards."));
     }
   }
 }
 
 void stringifyAndParseMethodSpecificData(const Vector<String>& supportedMethods,
                                          const ScriptValue& input,
-                                         Document& document,
                                          PaymentMethodDataPtr& output,
+                                         ExecutionContext& executionContext,
                                          ExceptionState& exceptionState) {
   DCHECK(!input.isEmpty());
   if (!input.v8Value()->IsObject() || input.v8Value()->IsArray()) {
     exceptionState.throwTypeError("Data should be a JSON-serializable object");
     return;
   }
 
   v8::Local<v8::String> value;
   if (!v8::JSON::Stringify(input.context(), input.v8Value().As<v8::Object>())
            .ToLocal(&value)) {
     exceptionState.throwTypeError(
         "Unable to parse payment method specific data");
     return;
   }
 
   output->stringified_data =
       v8StringToWebCoreString<String>(value, DoNotExternalize);
 
   // Serialize payment method specific data to be sent to the payment apps. The
   // payment apps are responsible for validating and processing their method
   // data asynchronously. Do not throw exceptions here.
   if (supportedMethods.contains("https://android.com/pay")) {
     setAndroidPayMethodData(input, output, exceptionState);
     if (exceptionState.hadException())
       exceptionState.clearException();
   }
   if (RuntimeEnabledFeatures::paymentRequestBasicCardEnabled() &&
       supportedMethods.contains("basic-card")) {
-    setBasicCardMethodData(input, document, output, exceptionState);
+    setBasicCardMethodData(input, output, executionContext, exceptionState);
     if (exceptionState.hadException())
       exceptionState.clearException();
   }
 }
 
 void validateAndConvertPaymentDetailsModifiers(
     const HeapVector<PaymentDetailsModifier>& input,
-    Document& document,
     Vector<PaymentDetailsModifierPtr>& output,
+    ExecutionContext& executionContext,
     ExceptionState& exceptionState) {
   if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment details modifier");
     return;
   }
 
   for (const PaymentDetailsModifier& modifier : input) {
     output.push_back(payments::mojom::blink::PaymentDetailsModifier::New());
     if (modifier.hasTotal()) {
@@ skipping 16 matching lines @@
           "Must specify at least one payment method identifier");
       return;
     }
 
     output.back()->method_data =
         payments::mojom::blink::PaymentMethodData::New();
     output.back()->method_data->supported_methods = modifier.supportedMethods();
 
     if (modifier.hasData() && !modifier.data().isEmpty()) {
       stringifyAndParseMethodSpecificData(
-          modifier.supportedMethods(), modifier.data(), document,
-          output.back()->method_data, exceptionState);
+          modifier.supportedMethods(), modifier.data(),
+          output.back()->method_data, executionContext, exceptionState);
     } else {
       output.back()->method_data->stringified_data = "";
     }
   }
 }
 
 String getSelectedShippingOption(
     const Vector<PaymentShippingOptionPtr>& shippingOptions) {
   String result;
   for (const PaymentShippingOptionPtr& shippingOption : shippingOptions) {
     if (shippingOption->selected)
       result = shippingOption->id;
   }
   return result;
 }
 
 void validateAndConvertPaymentDetails(const PaymentDetails& input,
                                       bool requestShipping,
-                                      Document& document,
                                       PaymentDetailsPtr& output,
                                       String& shippingOptionOutput,
+                                      ExecutionContext& executionContext,
                                       ExceptionState& exceptionState) {
   if (!input.hasTotal()) {
     exceptionState.throwTypeError("Must specify total");
     return;
   }
 
   validateAndConvertTotal(input.total(), output->total, exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (input.hasDisplayItems()) {
     validateAndConvertDisplayItems(input.displayItems(), output->display_items,
                                    exceptionState);
     if (exceptionState.hadException())
       return;
   }
 
   if (input.hasShippingOptions() && requestShipping) {
     validateAndConvertShippingOptions(input.shippingOptions(),
                                       output->shipping_options, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 
   shippingOptionOutput = getSelectedShippingOption(output->shipping_options);
 
   if (input.hasModifiers()) {
     validateAndConvertPaymentDetailsModifiers(
-        input.modifiers(), document, output->modifiers, exceptionState);
+        input.modifiers(), output->modifiers, executionContext, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 
   if (input.hasError() && !input.error().isNull()) {
     String errorMessage;
     if (!PaymentsValidators::isValidErrorMsgFormat(input.error(),
                                                    &errorMessage)) {
       exceptionState.throwTypeError(errorMessage);
       return;
     }
     output->error = input.error();
   } else {
     output->error = "";
   }
 }
 
 void validateAndConvertPaymentMethodData(
     const HeapVector<PaymentMethodData>& input,
-    Document& document,
     Vector<payments::mojom::blink::PaymentMethodDataPtr>& output,
+    ExecutionContext& executionContext,
     ExceptionState& exceptionState) {
   if (input.isEmpty()) {
     exceptionState.throwTypeError(
         "Must specify at least one payment method identifier");
     return;
   }
 
   for (const PaymentMethodData paymentMethodData : input) {
     if (paymentMethodData.supportedMethods().isEmpty()) {
       exceptionState.throwTypeError(
           "Must specify at least one payment method identifier");
       return;
     }
 
     output.push_back(payments::mojom::blink::PaymentMethodData::New());
     output.back()->supported_methods = paymentMethodData.supportedMethods();
 
     if (paymentMethodData.hasData() && !paymentMethodData.data().isEmpty()) {
-      stringifyAndParseMethodSpecificData(paymentMethodData.supportedMethods(),
-                                          paymentMethodData.data(), document,
-                                          output.back(), exceptionState);
+      stringifyAndParseMethodSpecificData(
+          paymentMethodData.supportedMethods(), paymentMethodData.data(),
+          output.back(), executionContext, exceptionState);
     } else {
       output.back()->stringified_data = "";
     }
   }
 }
 
 String getValidShippingType(const String& shippingType) {
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
   };
@@ skipping 59 matching lines @@
   }
 
   // Otherwise, paymentrequest is not allowed. (If we reach here and this is
   // the main frame, then paymentrequest must have been disabled by FP.)
   return false;
 }
 
 }  // namespace
 
 PaymentRequest* PaymentRequest::create(
-    Document& document,
+    ScriptState* scriptState,
     const HeapVector<PaymentMethodData>& methodData,
     const PaymentDetails& details,
     ExceptionState& exceptionState) {
-  return new PaymentRequest(document, methodData, details, PaymentOptions(),
+  return new PaymentRequest(scriptState, methodData, details, PaymentOptions(),
                             exceptionState);
 }
 
 PaymentRequest* PaymentRequest::create(
-    Document& document,
+    ScriptState* scriptState,
     const HeapVector<PaymentMethodData>& methodData,
     const PaymentDetails& details,
     const PaymentOptions& options,
     ExceptionState& exceptionState) {
-  return new PaymentRequest(document, methodData, details, options,
+  return new PaymentRequest(scriptState, methodData, details, options,
                             exceptionState);
 }
 
 PaymentRequest::~PaymentRequest() {}
 
 ScriptPromise PaymentRequest::show(ScriptState* scriptState) {
-  if (!m_paymentProvider.is_bound() || m_showResolver)
+  if (!m_paymentProvider.is_bound() || m_showResolver) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError, "Already called show() once"));
+  }
 
-  if (!scriptState->domWindow() || !scriptState->domWindow()->frame())
+  if (!scriptState->contextIsValid() || !scriptState->domWindow() ||
+      !scriptState->domWindow()->frame()) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "Cannot show the payment request"));
+  }
 
   m_paymentProvider->Show();
 
   m_showResolver = ScriptPromiseResolver::create(scriptState);
   return m_showResolver->promise();
 }
 
 ScriptPromise PaymentRequest::abort(ScriptState* scriptState) {
-  if (m_abortResolver)
+  if (!scriptState->contextIsValid()) {
+    return ScriptPromise::rejectWithDOMException(
+        scriptState,
+        DOMException::create(InvalidStateError, "Cannot abort payment"));
+  }
+
+  if (m_abortResolver) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError,
                              "Cannot abort() again until the previous abort() "
                              "has resolved or rejected"));
+  }
 
-  if (!m_showResolver)
+  if (!m_showResolver) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError,
                              "Never called show(), so nothing to abort"));
+  }
 
   m_abortResolver = ScriptPromiseResolver::create(scriptState);
   m_paymentProvider->Abort();
   return m_abortResolver->promise();
 }
 
 ScriptPromise PaymentRequest::canMakePayment(ScriptState* scriptState) {
   if (!m_paymentProvider.is_bound() || m_canMakePaymentResolver ||
       !scriptState->contextIsValid()) {
     return ScriptPromise::rejectWithDOMException(
@@ skipping 14 matching lines @@
 const AtomicString& PaymentRequest::interfaceName() const {
   return EventTargetNames::PaymentRequest;
 }
 
 ExecutionContext* PaymentRequest::getExecutionContext() const {
   return ContextLifecycleObserver::getExecutionContext();
 }
 
 ScriptPromise PaymentRequest::complete(ScriptState* scriptState,
                                        PaymentComplete result) {
-  if (m_completeResolver)
+  if (!scriptState->contextIsValid()) {
+    return ScriptPromise::rejectWithDOMException(
+        scriptState,
+        DOMException::create(InvalidStateError, "Cannot complete payment"));
+  }
+
+  if (m_completeResolver) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "Already called complete() once"));
+  }
 
-  if (!m_completeTimer.isActive())
+  if (!m_completeTimer.isActive()) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
             InvalidStateError,
             "Timed out after 60 seconds, complete() called too late"));
+  }
 
   // User has cancelled the transaction while the website was processing it.
-  if (!m_paymentProvider)
+  if (!m_paymentProvider) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError, "Request cancelled"));
+  }
 
   m_completeTimer.stop();
 
   // The payment provider should respond in PaymentRequest::OnComplete().
   m_paymentProvider->Complete(payments::mojom::blink::PaymentComplete(result));
 
   m_completeResolver = ScriptPromiseResolver::create(scriptState);
   return m_completeResolver->promise();
 }
 
@@ skipping 11 matching lines @@
                            exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
   PaymentDetailsPtr validatedDetails =
       payments::mojom::blink::PaymentDetails::New();
-  validateAndConvertPaymentDetails(
-      details, m_options.requestShipping(),
-      *detailsScriptValue.getScriptState()->domWindow()->document(),
-      validatedDetails, m_shippingOption, exceptionState);
+  validateAndConvertPaymentDetails(details, m_options.requestShipping(),
+                                   validatedDetails, m_shippingOption,
+                                   *getExecutionContext(), exceptionState);
   if (exceptionState.hadException()) {
     m_showResolver->reject(
         DOMException::create(SyntaxError, exceptionState.message()));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
   m_paymentProvider->UpdateWith(std::move(validatedDetails));
 }
 
@@ skipping 14 matching lines @@
   visitor->trace(m_canMakePaymentResolver);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 void PaymentRequest::onCompleteTimeoutForTesting() {
   m_completeTimer.stop();
   onCompleteTimeout(0);
 }
 
-PaymentRequest::PaymentRequest(Document& document,
+PaymentRequest::PaymentRequest(ScriptState* scriptState,
                                const HeapVector<PaymentMethodData>& methodData,
                                const PaymentDetails& details,
                                const PaymentOptions& options,
                                ExceptionState& exceptionState)
-    : ContextLifecycleObserver(&document),
+    : ContextLifecycleObserver(scriptState->getExecutionContext()),
       m_options(options),
       m_clientBinding(this),
-      m_completeTimer(
-          TaskRunnerHelper::get(TaskType::MiscPlatformAPI, document.frame()),
-          this,
-          &PaymentRequest::onCompleteTimeout) {
+      m_completeTimer(TaskRunnerHelper::get(TaskType::MiscPlatformAPI, frame()),
+                      this,
+                      &PaymentRequest::onCompleteTimeout) {
   Vector<payments::mojom::blink::PaymentMethodDataPtr> validatedMethodData;
-  validateAndConvertPaymentMethodData(methodData, document, validatedMethodData,
-                                      exceptionState);
+  validateAndConvertPaymentMethodData(methodData, validatedMethodData,
+                                      *getExecutionContext(), exceptionState);
   if (exceptionState.hadException())
     return;
 
-  if (!document.isSecureContext()) {
+  if (!getExecutionContext()->isSecureContext()) {
     exceptionState.throwSecurityError("Must be in a secure context");
     return;
   }
 
-  if (!allowedToUsePaymentRequest(document.frame())) {
+  if (!allowedToUsePaymentRequest(frame())) {
     exceptionState.throwSecurityError(
         "Must be in a top-level browsing context or an iframe needs to specify "
         "'allowpaymentrequest' explicitly");
     return;
   }
 
   PaymentDetailsPtr validatedDetails =
       payments::mojom::blink::PaymentDetails::New();
   validateAndConvertPaymentDetails(details, m_options.requestShipping(),
-                                   document, validatedDetails, m_shippingOption,
-                                   exceptionState);
+                                   validatedDetails, m_shippingOption,
+                                   *getExecutionContext(), exceptionState);
   if (exceptionState.hadException())
     return;
 
   if (details.hasError()) {
     exceptionState.throwTypeError("Error message not allowed in constructor");
     return;
   }
 
   if (m_options.requestShipping())
     m_shippingType = getValidShippingType(m_options.shippingType());
 
-  document.frame()->interfaceProvider()->getInterface(
+  frame()->interfaceProvider()->getInterface(
       mojo::MakeRequest(&m_paymentProvider));
   m_paymentProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&PaymentRequest::OnError, wrapWeakPersistent(this),
                 PaymentErrorReason::UNKNOWN)));
   m_paymentProvider->Init(
       m_clientBinding.CreateInterfacePtrAndBind(),
       std::move(validatedMethodData), std::move(validatedDetails),
       payments::mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed(ExecutionContext*) {
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnShippingAddressChange(PaymentAddressPtr address) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
 
   String errorMessage;
   if (!PaymentsValidators::isValidShippingAddress(address, &errorMessage)) {
     m_showResolver->reject(DOMException::create(SyntaxError, errorMessage));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
   m_shippingAddress = new PaymentAddress(std::move(address));
-  PaymentRequestUpdateEvent* event = PaymentRequestUpdateEvent::create(
-      getExecutionContext(), EventTypeNames::shippingaddresschange);
+  PaymentRequestUpdateEvent* event =
+      PaymentRequestUpdateEvent::create(ScriptState::forMainWorld(frame()),
+                                        EventTypeNames::shippingaddresschange);
   event->setTarget(this);
   event->setPaymentDetailsUpdater(this);
   bool success = getExecutionContext()->getEventQueue()->enqueueEvent(event);
   DCHECK(success);
   ALLOW_UNUSED_LOCAL(success);
 }
 
 void PaymentRequest::OnShippingOptionChange(const String& shippingOptionId) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
   m_shippingOption = shippingOptionId;
   PaymentRequestUpdateEvent* event = PaymentRequestUpdateEvent::create(
-      getExecutionContext(), EventTypeNames::shippingoptionchange);
+      ScriptState::forMainWorld(frame()), EventTypeNames::shippingoptionchange);

[please use gerrit instead, 2017/02/19 18:53:02]

Is it OK to use the main world when notifying the merchant website that the user
has changed their shipping option? If not, please explain why
getExecutionContext() would be better than ScriptState::forMainWorld() here.

[Marijn Kruisselbrink, 2017/02/21 19:08:56]

Even though each world has it's own Window and Document javascript objects,
they're still backed by the same C++ Document instance. So getExecutionContext
is independent of which world you're using. That also means that since you're
only using the script state to then get the execution context, calling
ScriptState::forMainWorld is not wrong in that it will still always result in
the right behavior. It does seem wrong in that you really don't care about the
script state at this point, since all you're really using it for is to get the
correct TaskRunnerHelper, which would be the same for all script states
associated with the same execution context.

So possibly you want ::create methods for both ScriptState and ExecutionContext
in PaymentRequestUpdateEvent so you can use the non-deprcted
callwith=ScriptState for script created events, yet can still pass just the
execution context for c++ created events?

   event->setTarget(this);
   event->setPaymentDetailsUpdater(this);
   bool success = getExecutionContext()->getEventQueue()->enqueueEvent(event);
   DCHECK(success);
   ALLOW_UNUSED_LOCAL(success);
 }
 
 void PaymentRequest::OnPaymentResponse(PaymentResponsePtr response) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
@@ skipping 147 matching lines @@
   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