[Merge M-56] Return cached query result for canMakeActivePayment.

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;
@@ skipping 86 matching lines @@
          * </ul>
          */
         void onPaymentRequestServiceShowFailed();
 
         /**
          * Called when the canMakeActivePayment() request has been responded.
          */
         void onPaymentRequestServiceActivePaymentQueryResponded();
     }
 
+    /** The object to keep track of cached payment query results. */
+    private static class ActivePaymentQuery {
+        private final Set<PaymentRequestImpl> mObservers = new HashSet<>();
+        private final Set<String> mMethods;
+        private Boolean mResponse;
+
+        /**
+         * Keeps track of an active payment query.
+         *
+         * @param methods The payment methods that are being queried.
+         */
+        public ActivePaymentQuery(Set<String> methods) {
+            assert methods != null;
+            mMethods = methods;
+        }
+
+        /**
+         * Checks whether the given payment methods matches the previously queried payment methods.
+         *
+         * @param methods The payment methods that are being queried.
+         * @return True if the given methods match the previously queried payment methods.
+         */
+        public boolean matchesPaymentMethods(Set<String> methods) {
+            return mMethods.equals(methods);
+        }
+
+        /** @return Whether active payment can be made, or null if response is not known yet. */
+        public Boolean getPreviousResponse() {
+            return mResponse;
+        }
+
+        /** @param response Whether active payment can be made. */
+        public void setResponse(boolean response) {
+            if (mResponse == null) mResponse = response;
+            for (PaymentRequestImpl observer : mObservers) {
+                observer.respondActivePaymentQuery(mResponse.booleanValue());
+            }
+            mObservers.clear();
+        }
+
+        /** @param observer The observer to notify when the query response is known. */
+        public void addObserver(PaymentRequestImpl observer) {
+            mObservers.add(observer);
+        }
+    };
+
     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.
+     * this call. The mapping is shared among all instances of PaymentRequestImpl in the browser
+     * process on UI thread. The user can reset the throttling mechanism by restarting the browser.
      */
-    private static Map<String, Set<String>> sCanMakeActivePaymentQueries;
+    private static Map<String, ActivePaymentQuery> 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. */
@@ skipping 94 matching lines @@
                         }
                         mUI.setTitleBitmap(bitmap);
                     }
                 });
 
         mApps = PaymentAppFactory.create(mContext, webContents);
 
         mAddressEditor = new AddressEditor();
         mCardEditor = new CardEditor(webContents, mAddressEditor, sObserverForTest);
 
+        if (sCanMakeActivePaymentQueries == null) sCanMakeActivePaymentQueries = new ArrayMap<>();
+
         recordSuccessFunnelHistograms("Initiated");
     }
 
     /**
      * Called by the merchant website to initialize the payment request data.
      */
     @Override
     public void init(PaymentRequestClient client, PaymentMethodData[] methodData,
             PaymentDetails details, PaymentOptions options) {
         if (mClient != null || client == null) return;
@@ skipping 668 matching lines @@
         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)) {
-            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());
+        ActivePaymentQuery query = sCanMakeActivePaymentQueries.get(mOrigin);
+        if (query == null) {
+            query = new ActivePaymentQuery(mMethodData.keySet());
+            sCanMakeActivePaymentQueries.put(mOrigin, query);
             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 (!query.matchesPaymentMethods(mMethodData.keySet())) {
+            mClient.onCanMakeActivePayment(ActivePaymentQueryResult.QUERY_QUOTA_EXCEEDED);
             if (sObserverForTest != null) {
                 sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
             }
+            return;
+        }
+
+        if (query.getPreviousResponse() != null) {
+            respondActivePaymentQuery(query.getPreviousResponse().booleanValue());
+            return;
+        }
+
+        query.addObserver(this);
+        if (mPendingApps.isEmpty() && mPendingInstruments.isEmpty()) {
+            query.setResponse(mPaymentMethodsSection != null
+                    && mPaymentMethodsSection.getSelectedItem() != null);
         }
     }
 
+    private void respondActivePaymentQuery(boolean response) {
+        mClient.onCanMakeActivePayment(response
+                        ? ActivePaymentQueryResult.CAN_MAKE_ACTIVE_PAYMENT
+                        : ActivePaymentQueryResult.CANNOT_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 55 matching lines @@
         // > Complete autofill instruments.
         // > Incomplete autofill instruments.
         Collections.sort(mPendingAutofillInstruments, COMPLETENESS_COMPARATOR);
         mPendingInstruments.addAll(mPendingAutofillInstruments);
 
         // Log the number of suggested credit cards.
         mJourneyLogger.setNumberOfSuggestionsShown(PaymentRequestJourneyLogger.SECTION_CREDIT_CARDS,
                 mPendingAutofillInstruments.size());
 
         mPendingAutofillInstruments.clear();
-        mPendingAutofillInstruments = null;
 
         // 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();
-            }
-        }
+        ActivePaymentQuery query = sCanMakeActivePaymentQueries.get(mOrigin);
+        if (query != null) query.setResponse(selection == 0);
 
         // 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();
     }
@@ skipping 169 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");
         }
     }
 }