Add canMakeActivePayment() method to web payments.

third_party/WebKit/Source/modules/payments/PaymentRequest.cpp

Index: third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
diff --git a/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp b/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
index 6ce9aeb6f6529eb8772fc9e81a7a54c6b1885fca..053d0f5df9eeb202bc66ad410a8839cfff623e01 100644
--- a/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
+++ b/third_party/WebKit/Source/modules/payments/PaymentRequest.cpp
@@ -33,14 +33,15 @@
 #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;
@@ -48,10 +49,13 @@ 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(
@@ -94,8 +98,7 @@ 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());
@@ -140,7 +143,7 @@ struct TypeConverter<PaymentDetailsPtr, blink::PaymentDetails> {
     if (input.hasError())
       output->error = input.error();
     else
-      output->error = WTF::emptyString();
+      output->error = emptyString();
 
     return output;
   }
@@ -168,14 +171,13 @@ struct TypeConverter<PaymentOptionsPtr, blink::PaymentOptions> {
 
 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;
@@ -418,9 +420,8 @@ String getValidShippingType(const String& 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);
 
@@ -455,15 +456,12 @@ bool allowedToUsePaymentRequest(const Frame* frame) {
   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;
@@ -528,6 +526,20 @@ ScriptPromise PaymentRequest::abort(ScriptState* scriptState) {
   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;
 }
@@ -620,6 +632,7 @@ DEFINE_TRACE(PaymentRequest) {
   visitor->trace(m_showResolver);
   visitor->trace(m_completeResolver);
   visitor->trace(m_abortResolver);
+  visitor->trace(m_canMakeActivePaymentResolver);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
@@ -676,7 +689,7 @@ PaymentRequest::PaymentRequest(ScriptState* scriptState,
       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),
@@ -690,8 +703,7 @@ void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
-void PaymentRequest::OnShippingAddressChange(
-    payments::mojom::blink::PaymentAddressPtr address) {
+void PaymentRequest::OnShippingAddressChange(PaymentAddressPtr address) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
 
@@ -777,7 +789,7 @@ void PaymentRequest::OnPaymentResponse(
   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;
@@ -788,15 +800,15 @@ void PaymentRequest::OnError(mojo::PaymentErrorReason error) {
   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";
@@ -814,6 +826,9 @@ void PaymentRequest::OnError(mojo::PaymentErrorReason error) {
 
     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);
@@ -823,6 +838,9 @@ void PaymentRequest::OnError(mojo::PaymentErrorReason error) {
 
     if (m_abortResolver)
       m_abortResolver->reject(message);
+
+    if (m_canMakeActivePaymentResolver)
+      m_canMakeActivePaymentResolver->reject(message);
   }
 
   clearResolversAndCloseMojoConnection();
@@ -849,6 +867,24 @@ void PaymentRequest::OnAbort(bool abortedSuccessfully) {
   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();
@@ -859,6 +895,7 @@ void PaymentRequest::clearResolversAndCloseMojoConnection() {
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
+  m_canMakeActivePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();