Rename canMakeActivePayment to canMakePayment

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 21 matching lines @@
 import org.chromium.chrome.browser.tab.Tab;
 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.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.CanMakePaymentQueryResult;
 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;
@@ skipping 41 matching lines @@
          * 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.
+         * Called when the canMakePayment() request has been responded.
          */
-        void onPaymentRequestServiceActivePaymentQueryResponded();
+        void onPaymentRequestServiceCanMakePaymentQueryResponded();
     }
 
     /** The object to keep track of cached payment query results. */
-    private static class ActivePaymentQuery {
+    private static class CanMakePaymentQuery {
         private final Set<PaymentRequestImpl> mObservers = new HashSet<>();
         private final Set<String> mMethods;
         private Boolean mResponse;
 
         /**
-         * Keeps track of an active payment query.
+         * Keeps track of a payment query.
          *
          * @param methods The payment methods that are being queried.
          */
-        public ActivePaymentQuery(Set<String> methods) {
+        public CanMakePaymentQuery(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. */
+        /** @return Whether 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. */
+        /** @param response Whether payment can be made. */
         public void setResponse(boolean response) {
             if (mResponse == null) mResponse = response;
             for (PaymentRequestImpl observer : mObservers) {
-                observer.respondActivePaymentQuery(mResponse.booleanValue());
+                observer.respondCanMakePaymentQuery(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;
+    /** Every origin can call canMakePayment() every 30 minutes. */
+    private static final int CAN_MAKE_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()
+     * In-memory mapping of the origins of websites that have recently called canMakePayment()
      * to the list of the payment methods that were been queried. Used for throttling the usage of
      * 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, ActivePaymentQuery> sCanMakeActivePaymentQueries;
+    private static Map<String, CanMakePaymentQuery> sCanMakePaymentQueries;
 
     /** 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 52 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;
+    private boolean mQueriedCanMakePayment;
     private CurrencyStringFormatter mFormatter;
 
     /** True if any of the requested payment methods are supported. */
     private boolean mArePaymentMethodsSupported;
 
     /** The helper to create and fill the response to send to the merchant. */
     private PaymentResponseHelper mPaymentResponseHelper;
 
     /**
      * Builds the PaymentRequest service implementation.
@@ skipping 28 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<>();
+        if (sCanMakePaymentQueries == null) sCanMakePaymentQueries = 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) {
@@ skipping 722 matching lines @@
     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() {
+    public void canMakePayment() {
         if (mClient == null) return;
 
-        ActivePaymentQuery query = sCanMakeActivePaymentQueries.get(mOrigin);
+        CanMakePaymentQuery query = sCanMakePaymentQueries.get(mOrigin);
         if (query == null) {
-            query = new ActivePaymentQuery(mMethodData.keySet());
-            sCanMakeActivePaymentQueries.put(mOrigin, query);
+            query = new CanMakePaymentQuery(mMethodData.keySet());
+            sCanMakePaymentQueries.put(mOrigin, query);
             mHandler.postDelayed(new Runnable() {
                 @Override
                 public void run() {
-                    sCanMakeActivePaymentQueries.remove(mOrigin);
+                    sCanMakePaymentQueries.remove(mOrigin);
                 }
-            }, CAN_MAKE_ACTIVE_PAYMENT_QUERY_PERIOD_MS);
+            }, CAN_MAKE_PAYMENT_QUERY_PERIOD_MS);
         }
 
         if (!query.matchesPaymentMethods(mMethodData.keySet())) {
-            mClient.onCanMakeActivePayment(ActivePaymentQueryResult.QUERY_QUOTA_EXCEEDED);
+            mClient.onCanMakePayment(CanMakePaymentQueryResult.QUERY_QUOTA_EXCEEDED);
             if (sObserverForTest != null) {
-                sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
+                sObserverForTest.onPaymentRequestServiceCanMakePaymentQueryResponded();
             }
             return;
         }
 
         if (query.getPreviousResponse() != null) {
-            respondActivePaymentQuery(query.getPreviousResponse().booleanValue());
+            respondCanMakePaymentQuery(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);
+    private void respondCanMakePaymentQuery(boolean response) {
+        mClient.onCanMakePayment(response
+                        ? CanMakePaymentQueryResult.CAN_MAKE_PAYMENT
+                        : CanMakePaymentQueryResult.CANNOT_MAKE_PAYMENT);
         if (sObserverForTest != null) {
-            sObserverForTest.onPaymentRequestServiceActivePaymentQueryResponded();
+            sObserverForTest.onPaymentRequestServiceCanMakePaymentQueryResponded();
         }
     }
 
     /**
      * Called when the renderer closes the Mojo connection.
      */
     @Override
     public void close() {
         if (mClient == null) return;
         closeClient();
@@ skipping 71 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;
             }
         }
 
-        ActivePaymentQuery query = sCanMakeActivePaymentQueries.get(mOrigin);
+        CanMakePaymentQuery query = sCanMakePaymentQueries.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();
 
         updateInstrumentModifiedTotals();
 
@@ skipping 193 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");
         }
     }
 }