PaymentRequest Mojo bindings.

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/JSONValuesForV8.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.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 "modules/EventTargetModulesNames.h"
+#include "modules/payments/PaymentItem.h"
+#include "modules/payments/PaymentResponse.h"
+#include "modules/payments/PaymentsValidators.h"
 #include "modules/payments/ShippingAddress.h"
+#include "modules/payments/ShippingOption.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "public/platform/Platform.h"
+#include <utility>
 
 namespace blink {
+namespace {
+
+template <typename T>
+bool areValidItems(HeapVector<T> items, ExceptionState& exceptionState)

[Marijn Kruisselbrink, 2016/03/25 17:13:31]

Maybe add a comment explaining why this is a template function/what types this
is used for?

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+{
+    String errorMessage;
+    for (const auto& item : items) {
+        if (!item.hasId()) {
+            exceptionState.throwTypeError("Item id required");
+            return false;
+        }
+
+        if (!item.hasLabel()) {
+            exceptionState.throwTypeError("Item label required");
+            return false;
+        }
+
+        if (!item.hasAmount()) {
+            exceptionState.throwTypeError("Currency amount required");
+            return false;
+        }
+
+        if (!item.amount().hasCurrencyCode()) {
+            exceptionState.throwTypeError("Currency code required");
+            return false;
+        }
+
+        if (!item.amount().hasValue()) {
+            exceptionState.throwTypeError("Currency value required");
+            return false;
+        }
+
+        if (!isValidCurrencyCodeFormat(item.amount().currencyCode(), &errorMessage)) {
+            exceptionState.throwTypeError(errorMessage);
+            return false;
+        }
+
+        if (!isValidAmountFormat(item.amount().value(), &errorMessage)) {
+            exceptionState.throwTypeError(errorMessage);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+template <typename Output, typename Input>

[Marijn Kruisselbrink, 2016/03/25 17:13:30]

Same here, without already knowing the rest of the code it is unclear why this
is a template/what types this is used for.

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+void toMojoItem(const Input& input, Output& output)
+{
+    output->id = input.id();
+    output->label = input.label();
+    output->amount = mojom::wtf::CurrencyAmount::New();
+    output->amount->currency_code = input.amount().currencyCode();
+    output->amount->value = input.amount().value();
+}
+
+mojom::wtf::PaymentDetailsPtr toMojoPaymentDetails(const PaymentDetails& input)

[Marijn Kruisselbrink, 2016/03/25 17:13:30]

All these "toMojo*" methods should probably be specializations of
mojo::TypeConverter, rather than being your own custom methods (at least that's
my understanding of what "typical" mojo usage looks like/does for conversions
to/from mojo types/structs).

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+{
+    mojom::wtf::PaymentDetailsPtr output = mojom::wtf::PaymentDetails::New();
+    output->items = mojo::WTFArray<mojom::wtf::PaymentItemPtr>::New(input.items().size());
+    for (size_t i = 0; i < input.items().size(); ++i) {
+        output->items[i] = mojom::wtf::PaymentItem::New();
+        toMojoItem(input.items()[i], output->items[i]);
+    }
+
+    output->shipping_options = mojo::WTFArray<mojom::wtf::ShippingOptionPtr>::New(input.hasShippingOptions() ? input.shippingOptions().size() : 0);
+    if (input.hasShippingOptions()) {
+        for (size_t i = 0; i < input.shippingOptions().size(); ++i) {
+            output->shipping_options[i] = mojom::wtf::ShippingOption::New();
+            toMojoItem(input.shippingOptions()[i], output->shipping_options[i]);
+        }
+    }
+    return output;
+}
+
+mojom::wtf::PaymentOptionsPtr toMojoPaymentOptions(const PaymentOptions& input)
+{
+    mojom::wtf::PaymentOptionsPtr output = mojom::wtf::PaymentOptions::New();
+    output->request_shipping = input.requestShipping();
+    return output;
+}
+
+} // namespace
 
 // static
 PaymentRequest* PaymentRequest::create(ScriptState* scriptState, const Vector<String>& supportedMethods, const PaymentDetails& details, ExceptionState& exceptionState)
 {
     return new PaymentRequest(scriptState, supportedMethods, details, PaymentOptions(), ScriptValue(), exceptionState);
 }
 
 // static
 PaymentRequest* PaymentRequest::create(ScriptState* scriptState, const Vector<String>& supportedMethods, const PaymentDetails& details, const PaymentOptions& options, ExceptionState& exceptionState)
 {
     return new PaymentRequest(scriptState, supportedMethods, details, options, ScriptValue(), exceptionState);
 }
 
 // static
 PaymentRequest* PaymentRequest::create(ScriptState* scriptState, const Vector<String>& supportedMethods, const PaymentDetails& details, const PaymentOptions& options, const ScriptValue& data, ExceptionState& exceptionState)
 {
     return new PaymentRequest(scriptState, supportedMethods, details, options, data, exceptionState);
 }
 
 PaymentRequest::~PaymentRequest()
 {
 }
 
 ScriptPromise PaymentRequest::show(ScriptState* scriptState)
 {
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, "Not implemented."));
+    if (m_showResolver)
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "Already called show() once"));
+
+    ASSERT(!m_paymentProvider.is_bound());

[Marijn Kruisselbrink, 2016/03/25 17:13:31]

DCHECK?

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+    blink::Platform::current()->connectToRemoteService(mojo::GetProxy(&m_paymentProvider));

[Marijn Kruisselbrink, 2016/03/25 17:13:30]

Maybe add a TODO to handle errors for the two mojo connections?

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+    m_paymentProvider->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
+    m_paymentProvider->Show(std::move(m_supportedMethods), toMojoPaymentDetails(m_details), toMojoPaymentOptions(m_options), m_stringifiedData.isNull() ? "" : m_stringifiedData);
+
+    m_showResolver = ScriptPromiseResolver::create(scriptState);
+    return m_showResolver->promise();
 }
 
-void PaymentRequest::abort()
+void PaymentRequest::abort(ExceptionState& exceptionState)
 {
+    if (!m_showResolver) {
+        exceptionState.throwDOMException(InvalidStateError, "Never called show(), so nothing to abort");
+        return;
+    }
+
+    m_paymentProvider->Abort();
 }
 
 const AtomicString& PaymentRequest::interfaceName() const
 {
     return EventTargetNames::PaymentRequest;
 }
 
 ExecutionContext* PaymentRequest::getExecutionContext() const
 {
     return m_scriptState->getExecutionContext();
 }
 
+ScriptPromise PaymentRequest::complete(ScriptState* scriptState, bool success)
+{
+    if (m_completeResolver)
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "Already called complete() once"));
+
+    m_completeResolver = ScriptPromiseResolver::create(scriptState);
+    m_paymentProvider->Complete(success);
+
+    return m_completeResolver->promise();
+}
+
 DEFINE_TRACE(PaymentRequest)
 {
     visitor->trace(m_details);
     visitor->trace(m_options);
     visitor->trace(m_shippingAddress);
+    visitor->trace(m_showResolver);
+    visitor->trace(m_completeResolver);
     RefCountedGarbageCollectedEventTargetWithInlineData<PaymentRequest>::trace(visitor);
 }
 
 PaymentRequest::PaymentRequest(ScriptState* scriptState, const Vector<String>& supportedMethods, const PaymentDetails& details, const PaymentOptions& options, const ScriptValue& data, ExceptionState& exceptionState)
     : m_scriptState(scriptState)
     , m_supportedMethods(supportedMethods)
     , m_details(details)
     , m_options(options)
+    , m_clientBinding(this)
 {
+    // TODO(rouslan): Also check for a top-level browsing context.
+    // https://github.com/w3c/browser-payment-api/issues/2
+    if (!scriptState->getExecutionContext()->isSecureContext()) {
+        exceptionState.throwSecurityError("Must be in a secure context");
+        return;
+    }
+
+    if (supportedMethods.isEmpty()) {
+        exceptionState.throwTypeError("Must specify at least one payment methods identifiers");

[Marijn Kruisselbrink, 2016/03/25 17:13:30]

"one payment methods identifiers" doesn't seem like correct English. "one
payment method identifier" would perhaps be better?

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+        return;
+    }
+
+    if (!details.hasItems()) {
+        exceptionState.throwTypeError("Must specify items");
+        return;
+    }
+
+    if (details.items().isEmpty()) {
+        exceptionState.throwTypeError("Must specify at least one item");
+        return;
+    }
+
+    if (!areValidItems(details.items(), exceptionState))
+        return;
+
+    if (details.hasShippingOptions() && !areValidItems(details.shippingOptions(), exceptionState))
+        return;
+
     if (!data.isEmpty()) {
         RefPtr<JSONValue> value = toJSONValue(data.context(), data.v8Value());
-        if (value && value->getType() == JSONValue::TypeObject)
-            m_stringifiedData = JSONObject::cast(value)->toJSONString();
+        if (value && !value->isNull()) {
+            if (value->getType() != JSONValue::TypeObject) {
+                exceptionState.throwTypeError("Payment method specific data should be a JSON-serializable object");
+                return;
+            }
+
+            RefPtr<JSONObject> jsonData = JSONObject::cast(value);
+            for (const auto& paymentMethodSpecificKeyValue : *jsonData) {
+                if (!supportedMethods.contains(paymentMethodSpecificKeyValue.key)) {
+                    exceptionState.throwTypeError("'" + paymentMethodSpecificKeyValue.key + "' should match one of the payment method identifiers");
+                    return;
+                }
+                if (!paymentMethodSpecificKeyValue.value || paymentMethodSpecificKeyValue.value->isNull() || paymentMethodSpecificKeyValue.value->getType() != JSONValue::TypeObject) {
+                    exceptionState.throwTypeError("Data for '" + paymentMethodSpecificKeyValue.key + "' should be a JSON-serializable object");
+                    return;
+                }
+            }
+
+            m_stringifiedData = jsonData->toJSONString();
+        }
     }
+
+    if (details.hasShippingOptions() && details.shippingOptions().size() == 1)
+        m_shippingOption = details.shippingOptions()[0].id();
+}
+
+void PaymentRequest::OnShippingAddressChange(mojom::wtf::ShippingAddressPtr address)
+{
+    ASSERT(m_showResolver);
+    ASSERT(!m_completeResolver);
+
+    // TODO(rouslan): Should the merchant website be notified of invalid shipping address
+    // from the browser or the payment app?
+    String errorMessage;
+    if (!isValidRegionCodeFormat(address->region_code, &errorMessage)) {
+        m_showResolver->reject(DOMException::create(SyntaxError, errorMessage));
+        return;
+    }
+
+    if (!isValidLanguageCodeFormat(address->language_code, &errorMessage)) {
+        m_showResolver->reject(DOMException::create(SyntaxError, errorMessage));
+        return;
+    }
+
+    if (!isValidScriptCodeFormat(address->script_code, &errorMessage)) {
+        m_showResolver->reject(DOMException::create(SyntaxError, errorMessage));
+        return;
+    }
+
+    if (address->language_code.isEmpty() && !address->script_code.isEmpty()) {
+        m_showResolver->reject(DOMException::create(SyntaxError, "If language code is empty, then script code should also be empty"));
+        return;
+    }
+
+    m_shippingAddress = new ShippingAddress(std::move(address));
+    RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::shippingaddresschange);
+    event->setTarget(this);
+    getExecutionContext()->getEventQueue()->enqueueEvent(event);
+}
+
+void PaymentRequest::OnShippingOptionChange(const String& shippingOptionId)
+{
+    ASSERT(m_showResolver);
+    ASSERT(!m_completeResolver);
+    m_shippingOption = shippingOptionId;
+    RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::shippingoptionchange);
+    event->setTarget(this);
+    getExecutionContext()->getEventQueue()->enqueueEvent(event);
+}
+
+void PaymentRequest::OnPaymentResponse(mojom::wtf::PaymentResponsePtr response)
+{
+    ASSERT(m_showResolver);
+    ASSERT(!m_completeResolver);
+    m_showResolver->resolve(new PaymentResponse(std::move(response), this));
+}
+
+void PaymentRequest::OnError()
+{
+    if (m_completeResolver) {
+        m_completeResolver->reject(DOMException::create(SyntaxError, "Request cancelled"));
+        return;
+    }
+    ASSERT(m_showResolver);
+    m_showResolver->reject(DOMException::create(SyntaxError, "Request cancelled"));
+    m_paymentProvider.reset();

[Marijn Kruisselbrink, 2016/03/25 17:13:30]

I wonder if wherever the connection to the paymentProvider is closed you also
want to call Close() on the client binding? It probably doesn't matter, since
it's likely that closing the connection to the provider will cause that provider
to also close the connection to the client, but might still be cleaner to be
explicit.

[please use gerrit instead, 2016/03/25 19:26:37]

Done.

+}
+
+void PaymentRequest::OnComplete()
+{
+    ASSERT(m_completeResolver);
+    m_completeResolver->resolve();
+    m_paymentProvider.reset();
 }
 
 } // namespace blink