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/ShippingAddress.h"
+#include "modules/payments/ShippingOption.h"
+#include "platform/payments/PlatformPaymentDetails.h"
+#include "platform/payments/PlatformPaymentItem.h"
+#include "platform/payments/PlatformPaymentOptions.h"
+#include "platform/payments/PlatformShippingOption.h"
 
 namespace blink {
+namespace {
+
+template <typename Output, typename Input>
+Output toPlatformItem(const Input& input)
+{
+    Output output;
+    output.id = input.id();
+    output.label = input.label();
+    if (input.hasAmount()) {
+        output.amount.currencyCode = input.amount().currencyCode();
+        output.amount.value = input.amount().value();
+    }
+    return output;
+}
+
+PlatformPaymentDetails toPlatformPaymentDetails(const PaymentDetails& input)
+{
+    PlatformPaymentDetails output;
+    if (input.hasItems()) {
+        output.items.resize(input.items().size());
+        for (size_t i = 0; i < input.items().size(); ++i)
+            output.items[i] = toPlatformItem<PlatformPaymentItem, PaymentItem>(input.items()[i]);
+    }
+    if (input.hasShippingOptions()) {
+        output.shippingOptions.resize(input.shippingOptions().size());
+        for (size_t i = 0; i < input.shippingOptions().size(); ++i)
+            output.shippingOptions[i] = toPlatformItem<PlatformShippingOption, ShippingOption>(input.shippingOptions()[i]);
+    }
+    return output;
+}
+
+PlatformPaymentOptions toPlatformPaymentOptions(const PaymentOptions& input)
+{
+    PlatformPaymentOptions output;
+    output.requestShipping = 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 m_showResolver->promise().rejectWithDOMException(scriptState, DOMException::create(SyntaxError, "Already called show() once."));
+
+    m_showResolver = ScriptPromiseResolver::create(scriptState);
+    m_paymentRequestProxy.show(m_supportedMethods, toPlatformPaymentDetails(m_details), toPlatformPaymentOptions(m_options), m_stringifiedData);
+
+    return m_showResolver->promise();
 }
 
-void PaymentRequest::abort()
+void PaymentRequest::abort(ExceptionState& exceptionState)
 {
+    if (!m_showResolver) {
+        exceptionState.throwDOMException(SyntaxError, "Never called show(), so nothing to abort.");
+        return;
+    }
+
+    m_paymentRequestProxy.abort();
 }
 
 const AtomicString& PaymentRequest::interfaceName() const
 {
     return EventTargetNames::PaymentRequest;
 }
 
 ExecutionContext* PaymentRequest::executionContext() const
 {
     return m_scriptState->executionContext();
 }
 
+ScriptPromise PaymentRequest::complete(ScriptState* scriptState, bool success)
+{
+    if (m_completeResolver)
+        return m_completeResolver->promise().rejectWithDOMException(scriptState, DOMException::create(SyntaxError, "Already called complete() once."));
+
+    m_completeResolver = ScriptPromiseResolver::create(scriptState);
+    m_paymentRequestProxy.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_paymentRequestProxy(this)
 {
     if (!data.isEmpty()) {
         RefPtr<JSONValue> value = toJSONValue(data.context(), data.v8Value());
         if (value && value->getType() == JSONValue::TypeObject)
             m_stringifiedData = JSONObject::cast(value)->toJSONString();
     }
 }
 
+void PaymentRequest::onShippingAddressChange(const PlatformShippingAddress& address)
+{
+    ASSERT(m_showResolver);
+    m_shippingAddress = new ShippingAddress(address);
+    RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::shippingaddresschange);
+    event->setTarget(this);
+    executionContext()->eventQueue()->enqueueEvent(event);
+}
+
+void PaymentRequest::onShippingOptionChange(const String& shippingOption)
+{
+    ASSERT(m_showResolver);
+    m_shippingOption = shippingOption;
+    RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::shippingoptionchange);
+    event->setTarget(this);
+    executionContext()->eventQueue()->enqueueEvent(event);
+}
+
+void PaymentRequest::onPaymentResponse(const PlatformPaymentResponse& response)
+{
+    ASSERT(m_showResolver);
+    m_showResolver->resolve(new PaymentResponse(response, this));
+}
+
+void PaymentRequest::onError()
+{
+    ASSERT(m_showResolver);
+    m_showResolver->reject(DOMException::create(SyntaxError, "Request cancelled."));
+}
+
+void PaymentRequest::onComplete()
+{
+    ASSERT(m_completeResolver);
+    m_completeResolver->resolve();
+}
+
 } // namespace blink