Add canMakeActivePayment() method to web payments.

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/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8StringResource.h"
@@ skipping 15 matching lines @@
 #include "modules/payments/PaymentsValidators.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/wtf_array.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 <utility>
 
-namespace mojo {
-
+using payments::mojom::blink::ActivePaymentQueryResult;
+using payments::mojom::blink::PaymentAddressPtr;
 using payments::mojom::blink::PaymentCurrencyAmount;
 using payments::mojom::blink::PaymentCurrencyAmountPtr;
 using payments::mojom::blink::PaymentDetails;
 using payments::mojom::blink::PaymentDetailsModifier;
 using payments::mojom::blink::PaymentDetailsModifierPtr;
 using payments::mojom::blink::PaymentDetailsPtr;
+using payments::mojom::blink::PaymentDetailsPtr;
 using payments::mojom::blink::PaymentErrorReason;
 using payments::mojom::blink::PaymentItem;
 using payments::mojom::blink::PaymentItemPtr;
 using payments::mojom::blink::PaymentMethodData;
 using payments::mojom::blink::PaymentMethodDataPtr;
 using payments::mojom::blink::PaymentOptions;
 using payments::mojom::blink::PaymentOptionsPtr;
+using payments::mojom::blink::PaymentResponsePtr;
 using payments::mojom::blink::PaymentShippingOption;
 using payments::mojom::blink::PaymentShippingOptionPtr;
 using payments::mojom::blink::PaymentShippingType;
 
+namespace mojo {
+
 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();
     if (input.hasCurrencySystem())
       output->currencySystem = input.currencySystem();
     return output;
@@ skipping 22 matching lines @@
     output->selected = input.hasSelected() && input.selected();
     return output;
   }
 };
 
 template <>
 struct TypeConverter<PaymentDetailsModifierPtr, blink::PaymentDetailsModifier> {
   static PaymentDetailsModifierPtr Convert(
       const blink::PaymentDetailsModifier& input) {
     PaymentDetailsModifierPtr output = PaymentDetailsModifier::New();
-    output->supported_methods =
-        WTF::Vector<WTF::String>(input.supportedMethods());
+    output->supported_methods = input.supportedMethods();
 
     if (input.hasTotal())
       output->total = PaymentItem::From(input.total());
 
     if (input.hasAdditionalDisplayItems()) {
       for (size_t i = 0; i < input.additionalDisplayItems().size(); ++i) {
         output->additional_display_items.append(
             PaymentItem::From(input.additionalDisplayItems()[i]));
       }
     }
@@ skipping 24 matching lines @@
     if (input.hasModifiers()) {
       for (size_t i = 0; i < input.modifiers().size(); ++i) {
         output->modifiers.append(
             PaymentDetailsModifier::From(input.modifiers()[i]));
       }
     }
 
     if (input.hasError())
       output->error = input.error();
     else
-      output->error = WTF::emptyString();
+      output->error = emptyString();
 
     return output;
   }
 };
 
 template <>
 struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
   static PaymentOptionsPtr Convert(const blink::PaymentOptions& input) {
     PaymentOptionsPtr output = PaymentOptions::New();
     output->request_payer_name = input.requestPayerName();
     output->request_payer_email = input.requestPayerEmail();
     output->request_payer_phone = input.requestPayerPhone();
     output->request_shipping = input.requestShipping();
 
     if (input.shippingType() == "delivery")
       output->shipping_type = PaymentShippingType::DELIVERY;
     else if (input.shippingType() == "pickup")
       output->shipping_type = PaymentShippingType::PICKUP;
     else
       output->shipping_type = PaymentShippingType::SHIPPING;
 
     return output;
   }
 };
 
 template <>
 struct TypeConverter<WTFArray<PaymentMethodDataPtr>,
-                     WTF::Vector<blink::PaymentRequest::MethodData>> {
+                     Vector<blink::PaymentRequest::MethodData>> {
   static WTFArray<PaymentMethodDataPtr> Convert(
-      const WTF::Vector<blink::PaymentRequest::MethodData>& input) {
+      const Vector<blink::PaymentRequest::MethodData>& input) {
     WTFArray<PaymentMethodDataPtr> output(input.size());
     for (size_t i = 0; i < input.size(); ++i) {
       output[i] = PaymentMethodData::New();
-      output[i]->supported_methods =
-          WTF::Vector<WTF::String>(input[i].supportedMethods);
+      output[i]->supported_methods = input[i].supportedMethods;
       output[i]->stringified_data = input[i].stringifiedData;
     }
     return output;
   }
 };
 
 }  // namespace mojo
 
 namespace blink {
 namespace {
@@ skipping 222 matching lines @@
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
   };
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(validValues); i++) {
     if (shippingType == validValues[i])
       return shippingType;
   }
   return validValues[0];
 }
 
-payments::mojom::blink::PaymentDetailsPtr maybeKeepShippingOptions(
-    payments::mojom::blink::PaymentDetailsPtr details,
-    bool keep) {
+PaymentDetailsPtr maybeKeepShippingOptions(PaymentDetailsPtr details,
+                                           bool keep) {
   if (!keep)
     details->shipping_options.resize(0);
 
   return details;
 }
 
 bool allowedToUsePaymentRequest(const Frame* frame) {
   // To determine whether a Document object |document| is allowed to use the
   // feature indicated by attribute name |allowpaymentrequest|, run these steps:
 
@@ skipping 14 matching lines @@
   if (ownerElement && isHTMLIFrameElement(ownerElement)) {
     HTMLIFrameElement* iframe = toHTMLIFrameElement(ownerElement);
     if (HTMLIFrameElementPayments::from(*iframe).allowPaymentRequest(*iframe))
       return allowedToUsePaymentRequest(frame->tree().parent());
   }
 
   // 4. Return false.
   return false;
 }
 
-WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr>
-ConvertPaymentMethodData(
+Vector<PaymentMethodDataPtr> ConvertPaymentMethodData(
     const Vector<PaymentRequest::MethodData>& blinkMethods) {
-  WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr> mojoMethods(
-      blinkMethods.size());
+  Vector<PaymentMethodDataPtr> mojoMethods(blinkMethods.size());
   for (size_t i = 0; i < blinkMethods.size(); ++i) {
     mojoMethods[i] = payments::mojom::blink::PaymentMethodData::New();
-    mojoMethods[i]->supported_methods =
-        WTF::Vector<WTF::String>(blinkMethods[i].supportedMethods);
+    mojoMethods[i]->supported_methods = blinkMethods[i].supportedMethods;
     mojoMethods[i]->stringified_data = blinkMethods[i].stringifiedData;
   }
   return mojoMethods;
 }
 
 }  // namespace
 
 PaymentRequest* PaymentRequest::create(
     ScriptState* scriptState,
     const HeapVector<PaymentMethodData>& methodData,
@@ skipping 44 matching lines @@
     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::canMakeActivePayment(ScriptState* scriptState) {
+  if (!m_paymentProvider.is_bound() || m_canMakeActivePaymentResolver ||
+      !scriptState->contextIsValid()) {
+    return ScriptPromise::rejectWithDOMException(
+        scriptState, DOMException::create(InvalidStateError,
+                                          "Cannot query payment request"));
+  }
+
+  m_paymentProvider->CanMakeActivePayment();
+
+  m_canMakeActivePaymentResolver = ScriptPromiseResolver::create(scriptState);
+  return m_canMakeActivePaymentResolver->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();
@@ skipping 72 matching lines @@
     m_completeResolver->reject(DOMException::create(AbortError, error));
   clearResolversAndCloseMojoConnection();
 }
 
 DEFINE_TRACE(PaymentRequest) {
   visitor->trace(m_options);
   visitor->trace(m_shippingAddress);
   visitor->trace(m_showResolver);
   visitor->trace(m_completeResolver);
   visitor->trace(m_abortResolver);
+  visitor->trace(m_canMakeActivePaymentResolver);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 void PaymentRequest::onCompleteTimeoutForTesting() {
   m_completeTimer.stop();
   onCompleteTimeout(0);
 }
 
 PaymentRequest::PaymentRequest(ScriptState* scriptState,
@@ skipping 36 matching lines @@
   if (m_options.requestShipping()) {
     if (keepShippingOptions)
       m_shippingOption = getSelectedShippingOption(details);
     m_shippingType = getValidShippingType(m_options.shippingType());
   }
 
   scriptState->domWindow()->frame()->interfaceProvider()->getInterface(
       mojo::GetProxy(&m_paymentProvider));
   m_paymentProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&PaymentRequest::OnError, wrapWeakPersistent(this),
-                payments::mojom::blink::PaymentErrorReason::UNKNOWN)));
+                PaymentErrorReason::UNKNOWN)));
   m_paymentProvider->Init(
       m_clientBinding.CreateInterfacePtrAndBind(),
       ConvertPaymentMethodData(validatedMethodData),
       maybeKeepShippingOptions(
           payments::mojom::blink::PaymentDetails::From(details),
           keepShippingOptions && m_options.requestShipping()),
       payments::mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
-void PaymentRequest::OnShippingAddressChange(
-    payments::mojom::blink::PaymentAddressPtr address) {
+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;
   }
 
@@ skipping 65 matching lines @@
   m_completeTimer.startOneShot(completeTimeoutSeconds, BLINK_FROM_HERE);
 
   m_showResolver->resolve(new PaymentResponse(std::move(response), this));
 
   // Do not close the mojo connection here. The merchant website should call
   // PaymentResponse::complete(String), which will be forwarded over the mojo
   // connection to display a success or failure message to the user.
   m_showResolver.clear();
 }
 
-void PaymentRequest::OnError(mojo::PaymentErrorReason error) {
+void PaymentRequest::OnError(PaymentErrorReason error) {
   if (!Platform::current()) {
     // TODO(rockot): Clean this up once renderer shutdown sequence is fixed.
     return;
   }
 
   bool isError = false;
   ExceptionCode ec = UnknownError;
   String message;
 
   switch (error) {
-    case payments::mojom::blink::PaymentErrorReason::USER_CANCEL:
+    case PaymentErrorReason::USER_CANCEL:
       message = "Request cancelled";
       break;
-    case payments::mojom::blink::PaymentErrorReason::NOT_SUPPORTED:
+    case PaymentErrorReason::NOT_SUPPORTED:
       isError = true;
       ec = NotSupportedError;
       message = "The payment method is not supported";
       break;
-    case payments::mojom::blink::PaymentErrorReason::UNKNOWN:
+    case PaymentErrorReason::UNKNOWN:
       isError = true;
       ec = UnknownError;
       message = "Request failed";
       break;
   }
 
   DCHECK(!message.isEmpty());
 
   if (isError) {
     if (m_completeResolver)
       m_completeResolver->reject(DOMException::create(ec, message));
 
     if (m_showResolver)
       m_showResolver->reject(DOMException::create(ec, message));
 
     if (m_abortResolver)
       m_abortResolver->reject(DOMException::create(ec, message));
+
+    if (m_canMakeActivePaymentResolver)
+      m_canMakeActivePaymentResolver->reject(DOMException::create(ec, message));
   } else {
     if (m_completeResolver)
       m_completeResolver->reject(message);
 
     if (m_showResolver)
       m_showResolver->reject(message);
 
     if (m_abortResolver)
       m_abortResolver->reject(message);
+
+    if (m_canMakeActivePaymentResolver)
+      m_canMakeActivePaymentResolver->reject(message);
   }
 
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnComplete() {
   DCHECK(m_completeResolver);
   m_completeResolver->resolve();
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnAbort(bool abortedSuccessfully) {
   DCHECK(m_abortResolver);
   DCHECK(m_showResolver);
 
   if (!abortedSuccessfully) {
     m_abortResolver->reject(DOMException::create(InvalidStateError));
     m_abortResolver.clear();
     return;
   }
 
   m_showResolver->reject(DOMException::create(AbortError));
   m_abortResolver->resolve();
   clearResolversAndCloseMojoConnection();
 }
 
+void PaymentRequest::OnCanMakeActivePayment(ActivePaymentQueryResult result) {
+  DCHECK(m_canMakeActivePaymentResolver);
+
+  switch (result) {
+    case ActivePaymentQueryResult::CAN_MAKE_ACTIVE_PAYMENT:
+      m_canMakeActivePaymentResolver->resolve(true);
+      break;
+    case ActivePaymentQueryResult::CANNOT_MAKE_ACTIVE_PAYMENT:
+      m_canMakeActivePaymentResolver->resolve(false);
+      break;
+    case ActivePaymentQueryResult::QUERY_QUOTA_EXCEEDED:
+      m_canMakeActivePaymentResolver->reject("Query quota exceeded");

[Marijn Kruisselbrink, 2016/11/17 18:06:21]

I would expect the spec to say to reject with a QuotaExceededError, rather than
reject with a plain string.

[please use gerrit instead, 2016/11/17 20:07:21]

Done.

+      break;
+  }
+
+  m_canMakeActivePaymentResolver.clear();
+}
+
 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_canMakeActivePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink