Add canMakeActivePayment() method to web payments.

chrome/android/java/src/org/chromium/chrome/browser/payments/PaymentRequestImpl.java

 // 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.
 
 package org.chromium.chrome.browser.payments;
 
 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.os.Handler;
+import android.support.v4.util.ArrayMap;
 import android.text.TextUtils;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import org.chromium.base.Callback;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
@@ skipping 14 matching lines @@
 import org.chromium.chrome.browser.tabmodel.EmptyTabModelObserver;
 import org.chromium.chrome.browser.tabmodel.EmptyTabModelSelectorObserver;
 import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModel.TabSelectionType;
 import org.chromium.chrome.browser.tabmodel.TabModelObserver;
 import org.chromium.chrome.browser.tabmodel.TabModelSelectorObserver;
 import org.chromium.components.safejson.JsonSanitizer;
 import org.chromium.components.url_formatter.UrlFormatter;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.mojo.system.MojoException;
+import org.chromium.payments.mojom.ActivePaymentQueryResult;
 import org.chromium.payments.mojom.PaymentComplete;
 import org.chromium.payments.mojom.PaymentDetails;
 import org.chromium.payments.mojom.PaymentErrorReason;
 import org.chromium.payments.mojom.PaymentItem;
 import org.chromium.payments.mojom.PaymentMethodData;
 import org.chromium.payments.mojom.PaymentOptions;
 import org.chromium.payments.mojom.PaymentRequest;
 import org.chromium.payments.mojom.PaymentRequestClient;
 import org.chromium.payments.mojom.PaymentResponse;
 import org.chromium.payments.mojom.PaymentShippingOption;
 import org.chromium.payments.mojom.PaymentShippingType;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Android implementation of the PaymentRequest service defined in
  * components/payments/payment_request.mojom.
  */
 public class PaymentRequestImpl implements PaymentRequest, PaymentRequestUI.Client,
         PaymentApp.InstrumentsCallback, PaymentInstrument.InstrumentDetailsCallback,
         PaymentResponseHelper.PaymentResponseRequesterDelegate {
     /**
-     * Observer to be notified when PaymentRequest UI has been dismissed.
-     */
-    public interface PaymentRequestDismissObserver {
-        /**
-         * Called when PaymentRequest UI has been dismissed.
-         */
-        void onPaymentRequestDismissed();
-    }
-
-    /**
      * A test-only observer for the PaymentRequest service implementation.
      */
     public interface PaymentRequestServiceObserverForTest {
         /**
          * Called when an abort request was denied.
          */
         void onPaymentRequestServiceUnableToAbort();
 
         /**
          * Called when the controller is notified of billing address change, but does not alter the
          * editor UI.
          */
         void onPaymentRequestServiceBillingAddressChangeProcessed();
 
         /**
          * Called when the controller is notified of an expiration month change.
          */
         void onPaymentRequestServiceExpirationMonthChange();
 
         /**
          * Called when a show request failed. This can happen when:
          * <ul>
          *   <li>The merchant requests only unsupported payment methods.</li>
          *   <li>The merchant requests only payment methods that don't have instruments and are not
          *       able to add instruments from PaymentRequest UI.</li>
          * </ul>
          */
         void onPaymentRequestServiceShowFailed();
+
+        /**
+         * Called when the canMakeActivePayment() request has been responded.
+         */
+        void onPaymentRequestServiceActivePaymentQueryResponded();
     }
 
     private static final String TAG = "cr_PaymentRequest";
     private static final String ANDROID_PAY_METHOD_NAME = "https://android.com/pay";
     private static final int SUGGESTIONS_LIMIT = 4;
     private static final Comparator<Completable> COMPLETENESS_COMPARATOR =
             new Comparator<Completable>() {
                 @Override
                 public int compare(Completable a, Completable b) {
                     return (b.isComplete() ? 1 : 0) - (a.isComplete() ? 1 : 0);
                 }
             };
 
+    /** Every origin can call canMakeActivePayment() every 30 minutes. */
+    private static final int CAN_MAKE_ACTIVE_PAYMENT_QUERY_PERIOD_MS = 30 * 60 * 1000;
+
     private static PaymentRequestServiceObserverForTest sObserverForTest;
 
+    /** True if show() was called in any PaymentRequestImpl object. */
+    private static boolean sIsShowing;
+
+    /**
+     * In-memory mapping of the origins of websites that have recently called canMakeActivePayment()
+     * to the list of the payment methods that were been queried. Used for throttling the usage of
+     * this call. The user can clear the list by restarting the browser.
+     */
+    private static Map<String, Set<String>> sCanMakeActivePaymentQueries;
+
     /** Monitors changes in the TabModelSelector. */
     private final TabModelSelectorObserver mSelectorObserver = new EmptyTabModelSelectorObserver() {
         @Override
         public void onTabModelSelected(TabModel newModel, TabModel oldModel) {
             onDismiss();
         }
     };
 
     /** Monitors changes in the current TabModel. */
     private final TabModelObserver mTabModelObserver = new EmptyTabModelObserver() {
         @Override
         public void didSelectTab(Tab tab, TabSelectionType type, int lastId) {
             if (tab == null || tab.getId() != lastId) onDismiss();
         }
     };
 
     private final Handler mHandler = new Handler();
     private final ChromeActivity mContext;
-    private final PaymentRequestDismissObserver mDismissObserver;
     private final String mMerchantName;
     private final String mOrigin;
     private final List<PaymentApp> mApps;
     private final AddressEditor mAddressEditor;
     private final CardEditor mCardEditor;
     private final PaymentRequestJourneyLogger mJourneyLogger = new PaymentRequestJourneyLogger();
 
     private Bitmap mFavicon;
     private PaymentRequestClient mClient;
 
@@ skipping 27 matching lines @@
     private List<PaymentApp> mPendingApps;
     private List<PaymentInstrument> mPendingInstruments;
     private List<PaymentInstrument> mPendingAutofillInstruments;
     private SectionInformation mPaymentMethodsSection;
     private PaymentRequestUI mUI;
     private Callback<PaymentInformation> mPaymentInformationCallback;
     private boolean mPaymentAppRunning;
     private boolean mMerchantSupportsAutofillPaymentInstruments;
     private ContactEditor mContactEditor;
     private boolean mHasRecordedAbortReason;
+    private boolean mQueriedCanMakeActivePayment;
 
     /** True if any of the requested payment methods are supported. */
     private boolean mArePaymentMethodsSupported;
 
-    /** True if show() was called. */
-    private boolean mIsShowing;
-
     /** The helper to create and fill the response to send to the merchant. */
     private PaymentResponseHelper mPaymentResponseHelper;
 
     /**
      * Builds the PaymentRequest service implementation.
      *
      * @param context         The context where PaymentRequest has been invoked.
      * @param webContents     The web contents that have invoked the PaymentRequest API.
-     * @param dismissObserver The observer to notify when PaymentRequest UI has been dismissed.
      */
-    public PaymentRequestImpl(Activity context, WebContents webContents,
-            PaymentRequestDismissObserver dismissObserver) {
+    public PaymentRequestImpl(Activity context, WebContents webContents) {
         assert context != null;
         assert webContents != null;
-        assert dismissObserver != null;
 
         assert context instanceof ChromeActivity;
         mContext = (ChromeActivity) context;
 
-        mDismissObserver = dismissObserver;
         mMerchantName = webContents.getTitle();
         // The feature is available only in secure context, so it's OK to not show HTTPS.
         mOrigin = UrlFormatter.formatUrlForSecurityDisplay(webContents.getVisibleUrl(), false);
 
         final FaviconHelper faviconHelper = new FaviconHelper();
         faviconHelper.getLocalFaviconImageForURL(Profile.getLastUsedProfile(),
                 webContents.getVisibleUrl(),
                 mContext.getResources().getDimensionPixelSize(R.dimen.payments_favicon_size),
                 new FaviconHelper.FaviconImageCallback() {
                     @Override
@@ skipping 168 matching lines @@
 
         PaymentRequestMetrics.recordRequestedInformationHistogram(requestPayerEmail,
                 requestPayerPhone, requestShipping, requestPayerName);
     }
 
     /**
      * Called by the merchant website to show the payment request to the user.
      */
     @Override
     public void show() {
-        if (mClient == null || mIsShowing) return;
+        if (mClient == null) return;
 
-        mIsShowing = true;
+        if (sIsShowing) {
+            disconnectFromClientWithDebugMessage("A PaymentRequest UI is already showing");
+            return;
+        }
+
+        sIsShowing = true;
         if (disconnectIfNoPaymentMethodsSupported()) return;
 
         // Catch any time the user switches tabs.  Because the dialog is modal, a user shouldn't be
         // allowed to switch tabs, which can happen if the user receives an external Intent.
         mContext.getTabModelSelector().addObserver(mSelectorObserver);
         mContext.getCurrentTabModel().addObserver(mTabModelObserver);
 
         mUI.show();
         recordSuccessFunnelHistograms("Shown");
     }
 
     private static Map<String, JSONObject> getValidatedMethodData(
             PaymentMethodData[] methodData, CardEditor paymentMethodsCollector) {
         // Payment methodData are required.
         if (methodData == null || methodData.length == 0) return null;
-        Map<String, JSONObject> result = new HashMap<>();
+        Map<String, JSONObject> result = new ArrayMap<>();
         for (int i = 0; i < methodData.length; i++) {
             JSONObject data = null;
             if (!TextUtils.isEmpty(methodData[i].stringifiedData)) {
                 try {
                     data = new JSONObject(JsonSanitizer.sanitize(methodData[i].stringifiedData));
                 } catch (JSONException | IOException | IllegalStateException e) {
                     // Payment method specific data should be a JSON object.
                     // According to the payment request spec[1], for each method data,
                     // if the data field is supplied but is not a JSON-serializable object,
                     // then should throw a TypeError. So, we should return null here even if
@@ skipping 18 matching lines @@
         }
         return result;
     }
 
     /** Queries the installed payment apps for their instruments that merchant supports. */
     private void getMatchingPaymentInstruments() {
         mPendingApps = new ArrayList<>(mApps);
         mPendingInstruments = new ArrayList<>();
         mPendingAutofillInstruments = new ArrayList<>();
 
-        Map<PaymentApp, Map<String, JSONObject>> queryApps = new HashMap<>();
+        Map<PaymentApp, Map<String, JSONObject>> queryApps = new ArrayMap<>();
         for (int i = 0; i < mApps.size(); i++) {
             PaymentApp app = mApps.get(i);
             Map<String, JSONObject> appMethods =
                     filterMerchantMethodData(mMethodData, app.getAppMethodNames());
             if (appMethods == null) {
                 mPendingApps.remove(app);
             } else {
                 mArePaymentMethodsSupported = true;
                 mMerchantSupportsAutofillPaymentInstruments |= app instanceof AutofillPaymentApp;
                 queryApps.put(app, appMethods);
             }
         }
 
         // Query instruments after mMerchantSupportsAutofillPaymentInstruments has been initialized,
         // so a fast response from a non-autofill payment app at the front of the app list does not
         // cause NOT_SUPPORTED payment rejection.
         for (Map.Entry<PaymentApp, Map<String, JSONObject>> q : queryApps.entrySet()) {
             q.getKey().getInstruments(q.getValue(), this);
         }
     }
 
     /** Filter out merchant method data that's not relevant to a payment app. Can return null. */
     private static Map<String, JSONObject> filterMerchantMethodData(
             Map<String, JSONObject> merchantMethodData, Set<String> appMethods) {
         Map<String, JSONObject> result = null;
         for (String method : appMethods) {
             if (merchantMethodData.containsKey(method)) {
-                if (result == null) result = new HashMap<>();
+                if (result == null) result = new ArrayMap<>();
                 result.put(method, merchantMethodData.get(method));
             }
         }
         return result;
     }
 
     /**
      * Called by merchant to update the shipping options and line items after the user has selected
      * their shipping address or shipping option.
      */
@@ skipping 422 matching lines @@
      * Called when the merchant website has processed the payment.
      */
     @Override
     public void complete(int result) {
         if (mClient == null) return;
         recordSuccessFunnelHistograms("Completed");
         closeUI(PaymentComplete.FAIL != result);
     }
 
     /**
+     * Called by the merchant website to check if the user has complete payment instruments.
+     */
+    @Override
+    public void canMakeActivePayment() {
+        if (mClient == null) return;
+
+        if (sCanMakeActivePaymentQueries == null) sCanMakeActivePaymentQueries = new ArrayMap<>();
+
+        if (sCanMakeActivePaymentQueries.containsKey(mOrigin)) {

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

Is mOrigin the correct key to use here? I realize the spec is still a bit in
flux, but currently is written in terms of TLD, not origin. (and also is
WebContents::GetVisibleURL() rather than GetLastCommittedURL() the correct URL
to use to make security decisions?)

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

After reading the comments on these methods, I should always be using
GetLastCommittedURL() for mOrigin.

+            if (!mMethodData.keySet().equals(sCanMakeActivePaymentQueries.get(mOrigin))) {
+                mClient.onCanMakeActivePayment(ActivePaymentQueryResult.QUERY_QUOTA_EXCEEDED);
+                if (sObserverForTest != null) {
+                    sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
+                }
+                return;
+            }
+        } else {
+            sCanMakeActivePaymentQueries.put(mOrigin, mMethodData.keySet());
+            mHandler.postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    sCanMakeActivePaymentQueries.remove(mOrigin);
+                }
+            }, CAN_MAKE_ACTIVE_PAYMENT_QUERY_PERIOD_MS);
+        }
+
+        if (!mPendingApps.isEmpty() || !mPendingInstruments.isEmpty()) {
+            mQueriedCanMakeActivePayment = true;
+        } else {
+            mClient.onCanMakeActivePayment(mPaymentMethodsSection == null
+                    || mPaymentMethodsSection.getSelectedItem() == null
+                            ? ActivePaymentQueryResult.CANNOT_MAKE_ACTIVE_PAYMENT
+                            : ActivePaymentQueryResult.CAN_MAKE_ACTIVE_PAYMENT);
+            if (sObserverForTest != null) {
+                sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
+            }
+        }
+    }
+
+    /**
      * Called when the renderer closes the Mojo connection.
      */
     @Override
     public void close() {
         if (mClient == null) return;
         closeClient();
         closeUI(true);
         recordAbortReasonHistogram(PaymentRequestMetrics.ABORT_REASON_MOJO_RENDERER_CLOSING);
     }
 
@@ skipping 66 matching lines @@
         // Pre-select the first instrument on the list, if it is complete.
         int selection = SectionInformation.NO_SELECTION;
         if (!mPendingInstruments.isEmpty()) {
             PaymentInstrument first = mPendingInstruments.get(0);
             if (!(first instanceof AutofillPaymentInstrument)
                     || ((AutofillPaymentInstrument) first).isComplete()) {
                 selection = 0;
             }
         }
 
+        if (mQueriedCanMakeActivePayment) {
+            mQueriedCanMakeActivePayment = false;
+            mClient.onCanMakeActivePayment(selection == 0
+                            ? ActivePaymentQueryResult.CAN_MAKE_ACTIVE_PAYMENT
+                            : ActivePaymentQueryResult.CANNOT_MAKE_ACTIVE_PAYMENT);
+            if (sObserverForTest != null) {
+                sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
+            }
+        }
+
         // The list of payment instruments is ready to display.
         mPaymentMethodsSection = new SectionInformation(PaymentRequestUI.TYPE_PAYMENT_METHODS,
                 selection, mPendingInstruments);
 
         mPendingInstruments.clear();
 
         // UI has requested the full list of payment instruments. Provide it now.
         if (mPaymentInformationCallback != null) providePaymentInformation();
     }
 
     /**
      * If no payment methods are supported, disconnect from the client and return true.
      *
      * @return True if no payment methods are supported
      */
     private boolean disconnectIfNoPaymentMethodsSupported() {
         boolean waitingForPaymentApps = !mPendingApps.isEmpty() || !mPendingInstruments.isEmpty();
         boolean foundPaymentMethods =
                 mPaymentMethodsSection != null && !mPaymentMethodsSection.isEmpty();
         boolean userCanAddCreditCard = mMerchantSupportsAutofillPaymentInstruments
                 && !ChromeFeatureList.isEnabled(ChromeFeatureList.NO_CREDIT_CARD_ABORT);
 
         if (!mArePaymentMethodsSupported
-                || (mIsShowing && !waitingForPaymentApps && !foundPaymentMethods
+                || (sIsShowing && !waitingForPaymentApps && !foundPaymentMethods
                            && !userCanAddCreditCard)) {
             // All payment apps have responded, but none of them have instruments. It's possible to
             // add credit cards, but the merchant does not support them either. The payment request
             // must be rejected.
             disconnectFromClientWithDebugMessage("Requested payment methods have no instruments",
                     PaymentErrorReason.NOT_SUPPORTED);
             recordAbortReasonHistogram(mArePaymentMethodsSupported
                             ? PaymentRequestMetrics.ABORT_REASON_NO_MATCHING_PAYMENT_METHOD
                             : PaymentRequestMetrics.ABORT_REASON_NO_SUPPORTED_PAYMENT_METHOD);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
@@ skipping 96 matching lines @@
             mPaymentMethodsSection = null;
         }
 
         mContext.getTabModelSelector().removeObserver(mSelectorObserver);
         mContext.getCurrentTabModel().removeObserver(mTabModelObserver);
     }
 
     private void closeClient() {
         if (mClient != null) mClient.close();
         mClient = null;
-        mDismissObserver.onPaymentRequestDismissed();
+        sIsShowing = false;
     }
 
     @VisibleForTesting
     public static void setObserverForTest(PaymentRequestServiceObserverForTest observerForTest) {
         sObserverForTest = observerForTest;
     }
 
     /**
      * Records specific histograms related to the different steps of a successful checkout.
      */
@@ skipping 19 matching lines @@
                 "PaymentRequest.CheckoutFunnel.Aborted", abortReason,
                 PaymentRequestMetrics.ABORT_REASON_MAX);
 
         if (abortReason == PaymentRequestMetrics.ABORT_REASON_ABORTED_BY_USER) {
             mJourneyLogger.recordJourneyStatsHistograms("UserAborted");
         } else {
             mJourneyLogger.recordJourneyStatsHistograms("OtherAborted");
         }
     }
 }