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 "bindings/core/v8/ConditionalFeatures.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 298 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)
+ScriptPromise PaymentRequest::show() {
+  ScriptState* scriptState = ScriptState::forMainWorld(frame());

[Marijn Kruisselbrink, 2017/02/16 19:50:13]

Why is forMainWorld always the correct thing to do here? What if for example an
extension content script creates a PaymentRequest instance and then calls this
method? Before it would use the script state of the isolated world of the
extension, but now this would instead use the script state of the main world?

[please use gerrit instead, 2017/02/16 21:11:24]

Undone.

I'm not familiar with these "worlds", main or otherwise. Can you point me to
anything I can read up on them for future reference?

[haraken, 2017/02/17 01:27:31]

You're right. It's wrong to assume that this is for the main world.

You should always pass in a correct ScriptState from the caller side (in common
cases from the binding layer by using [CallWith=ScriptState]).

+  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)
+ScriptPromise PaymentRequest::abort() {
+  ScriptState* scriptState = ScriptState::forMainWorld(frame());
+  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) {
+ScriptPromise PaymentRequest::canMakePayment() {
+  ScriptState* scriptState = ScriptState::forMainWorld(frame());
   if (!m_paymentProvider.is_bound() || m_canMakePaymentResolver ||
       !scriptState->contextIsValid()) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "Cannot query payment request"));
   }
 
   m_paymentProvider->CanMakePayment();
 
   m_canMakePaymentResolver = ScriptPromiseResolver::create(scriptState);
   return m_canMakePaymentResolver->promise();
 }
 
 bool PaymentRequest::hasPendingActivity() const {
   return m_showResolver || m_completeResolver;
 }
 
 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)
+ScriptPromise PaymentRequest::complete(PaymentComplete result) {
+  ScriptState* scriptState = ScriptState::forMainWorld(frame());
+  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()),

[Marijn Kruisselbrink, 2017/02/16 19:50:13]

if you're only using the ScriptState to get the ExecutionContext, couldn't this
just be CallWith=ExecutionContext rather than CallWith=ScriptState?

[please use gerrit instead, 2017/02/16 21:11:24]

Did not know that's possible. Doing that now. Thank you for the tip! :-)

       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));
 }
 
@@ skipping 188 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