[Merge M-53] Autofill cards at the bottom of the PaymentRequest UI

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.text.TextUtils;
@@ skipping 35 matching lines @@
 
 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
  * third_party/WebKit/public/platform/modules/payments/payment_request.mojom.
  */
 public class PaymentRequestImpl implements PaymentRequest, PaymentRequestUI.Client,
         PaymentApp.InstrumentsCallback, PaymentInstrument.DetailsCallback {
 
     /**
@@ skipping 16 matching lines @@
          * <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();
     }
 
     private static final String TAG = "cr_PaymentRequest";
-
     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);
+                }
+            };
 
     private static PaymentRequestServiceObserverForTest sObserverForTest;
 
     private final Handler mHandler = new Handler();
 
     private Activity mContext;
     private String mMerchantName;
     private String mOrigin;
     private Bitmap mFavicon;
     private List<PaymentApp> mApps;
@@ skipping 16 matching lines @@
      * price string. This data is passed to the UI.
      */
     private ShoppingCart mUiShoppingCart;
 
     /**
      * The UI model for the shipping options. Includes the label and sublabel for each shipping
      * option. Also keeps track of the selected shipping option. This data is passed to the UI.
      */
     private SectionInformation mUiShippingOptions;
 
-    private HashMap<String, JSONObject> mMethodData;
+    private Map<String, JSONObject> mMethodData;
     private SectionInformation mShippingAddressesSection;
     private SectionInformation mContactSection;
     private List<PaymentApp> mPendingApps;
-    private int mFirstCompletePendingInstrument;
     private List<PaymentInstrument> mPendingInstruments;
+    private List<PaymentInstrument> mPendingAutofillInstruments;
     private SectionInformation mPaymentMethodsSection;
     private PaymentRequestUI mUI;
     private Callback<PaymentInformation> mPaymentInformationCallback;
     private boolean mMerchantNeedsShippingAddress;
     private boolean mPaymentAppRunning;
     private boolean mMerchantSupportsAutofillPaymentInstruments;
     private AddressEditor mAddressEditor;
     private CardEditor mCardEditor;
     private ContactEditor mContactEditor;
 
@@ skipping 84 matching lines @@
 
         if (!parseAndValidateDetailsOrDisconnectFromClient(details)) return;
 
         if (!getMatchingPaymentInstruments()) {
             disconnectFromClientWithDebugMessage("Requested payment methods are not supported",
                     PaymentErrorReason.NOT_SUPPORTED);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return;
         }
 
-        // Create a comparator to sort the suggestions by completeness.
-        Comparator<Completable> completenessComparator = new Comparator<Completable>() {
-            @Override
-            public int compare(Completable a, Completable b) {
-                if (a.isComplete() == b.isComplete()) {
-                    return 0;
-                } else if (a.isComplete()) {
-                    return -1;
-                } else {
-                    return 1;
-                }
-            }
-        };
-
         // If the merchant requests shipping and does not provide a selected shipping option, then
         // the merchant needs the shipping address to calculate the shipping price and availability.
         boolean requestShipping = options != null && options.requestShipping;
         mMerchantNeedsShippingAddress =
                 requestShipping && mUiShippingOptions.getSelectedItem() == null;
 
         boolean requestPayerPhone = options != null && options.requestPayerPhone;
         boolean requestPayerEmail = options != null && options.requestPayerEmail;
 
         List<AutofillProfile> profiles = null;
         if (requestShipping || requestPayerPhone || requestPayerEmail) {
             profiles = PersonalDataManager.getInstance().getProfilesToSuggest();
         }
 
         if (requestShipping) {
             List<AutofillAddress> addresses = new ArrayList<>();
 
             for (int i = 0; i < profiles.size(); i++) {
                 AutofillProfile profile = profiles.get(i);
                 mAddressEditor.addPhoneNumberIfValid(profile.getPhoneNumber());
 
                 boolean isComplete = mAddressEditor.isProfileComplete(profile);
                 addresses.add(new AutofillAddress(profile, isComplete));
             }
 
             // Suggest complete addresses first.
-            Collections.sort(addresses, completenessComparator);
+            Collections.sort(addresses, COMPLETENESS_COMPARATOR);
 
             // Limit the number of suggestions.
             addresses = addresses.subList(0, Math.min(addresses.size(), SUGGESTIONS_LIMIT));
 
             // Automatically select the first address if one is complete and if the merchant does
             // not require a shipping address to calculate shipping costs.
             int firstCompleteAddressIndex = SectionInformation.NO_SELECTION;
             if (!mMerchantNeedsShippingAddress && !addresses.isEmpty()
                     && addresses.get(0).isComplete()) {
                 firstCompleteAddressIndex = 0;
@@ skipping 26 matching lines @@
                         uniqueContactInfos.add(uniqueContactInfo);
 
                         boolean isComplete =
                                 mContactEditor.isContactInformationComplete(phone, email);
                         contacts.add(new AutofillContact(profile, phone, email, isComplete));
                     }
                 }
             }
 
             // Suggest complete contact infos first.
-            Collections.sort(contacts, completenessComparator);
+            Collections.sort(contacts, COMPLETENESS_COMPARATOR);
 
             // Limit the number of suggestions.
             contacts = contacts.subList(0, Math.min(contacts.size(), SUGGESTIONS_LIMIT));
 
             // Automatically select the first address if it is complete.
             int firstCompleteContactIndex = SectionInformation.NO_SELECTION;
             if (!contacts.isEmpty() && contacts.get(0).isComplete()) {
                 firstCompleteContactIndex = 0;
             }
 
             mContactSection = new SectionInformation(
                     PaymentRequestUI.TYPE_CONTACT_DETAILS, firstCompleteContactIndex, contacts);
         }
 
         mUI = new PaymentRequestUI(mContext, this, requestShipping,
                 requestPayerPhone || requestPayerEmail, mMerchantSupportsAutofillPaymentInstruments,
                 mMerchantName, mOrigin);
 
         if (mFavicon != null) mUI.setTitleBitmap(mFavicon);
         mFavicon = null;
 
         mAddressEditor.setEditorView(mUI.getEditorView());
         mCardEditor.setEditorView(mUI.getCardEditorView());
         if (mContactEditor != null) mContactEditor.setEditorView(mUI.getEditorView());
     }
 
-    private static HashMap<String, JSONObject> getValidatedMethodData(
+    private static Map<String, JSONObject> getValidatedMethodData(
             PaymentMethodData[] methodData, CardEditor paymentMethodsCollector) {
         // Payment methodData are required.
         if (methodData == null || methodData.length == 0) return null;
-        HashMap<String, JSONObject> result = new HashMap<>();
+        Map<String, JSONObject> result = new HashMap<>();
         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 19 matching lines @@
         return result;
     }
 
     /**
      * Queries the installed payment apps for their instruments that merchant supports.
      *
      * @return True if any of the requested payment methods are supported.
      */
     private boolean getMatchingPaymentInstruments() {
         mPendingApps = new ArrayList<>(mApps);
-        mFirstCompletePendingInstrument = SectionInformation.NO_SELECTION;
         mPendingInstruments = new ArrayList<>();
+        mPendingAutofillInstruments = new ArrayList<>();
         boolean arePaymentMethodsSupported = false;
 
+        Map<PaymentApp, JSONObject> queryApps = new HashMap<>();
         for (int i = 0; i < mApps.size(); i++) {
             PaymentApp app = mApps.get(i);
             Set<String> appMethods = app.getSupportedMethodNames();
             appMethods.retainAll(mMethodData.keySet());
             if (appMethods.isEmpty()) {
                 mPendingApps.remove(app);
             } else {
                 arePaymentMethodsSupported = true;
-                mMerchantSupportsAutofillPaymentInstruments = app instanceof AutofillPaymentApp;
-                app.getInstruments(mMethodData.get(appMethods.iterator().next()), this);
+                mMerchantSupportsAutofillPaymentInstruments |= app instanceof AutofillPaymentApp;
+                queryApps.put(app, mMethodData.get(appMethods.iterator().next()));
             }
         }
 
+        // 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, JSONObject> q : queryApps.entrySet()) {
+            q.getKey().getInstruments(q.getValue(), this);
+        }
+
         return arePaymentMethodsSupported;
     }
 
     /**
      * Called by merchant to update the shipping options and line items after the user has selected
      * their shipping address or shipping option.
      */
     @Override
     public void updateWith(PaymentDetails details) {
         if (mClient == null) return;
@@ skipping 436 matching lines @@
         closeUI(false);
     }
 
     /**
      * Called after retrieving the list of payment instruments in an app.
      */
     @Override
     public void onInstrumentsReady(PaymentApp app, List<PaymentInstrument> instruments) {
         mPendingApps.remove(app);
 
+        // Place the instruments into either "autofill" or "non-autofill" list to be displayed when
+        // all apps have responded.
         if (instruments != null) {
             for (int i = 0; i < instruments.size(); i++) {
                 PaymentInstrument instrument = instruments.get(i);
                 if (mMethodData.containsKey(instrument.getMethodName())) {
-                    checkForCompletePaymentInstrument(instrument, mPendingInstruments.size());
-                    mPendingInstruments.add(instrument);
+                    addPendingInstrument(instrument);
                 } else {
                     instrument.dismiss();
                 }
             }
         }
 
         // Some payment apps still have not responded. Continue waiting for them.
         if (!mPendingApps.isEmpty()) return;
 
         if (mPendingInstruments.isEmpty() && !mMerchantSupportsAutofillPaymentInstruments) {
             // 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);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return;
         }
 
+        // List order:
+        // > Non-autofill instruments.
+        // > Complete autofill instruments.
+        // > Incomplete autofill instruments.
+        Collections.sort(mPendingAutofillInstruments, COMPLETENESS_COMPARATOR);
+        mPendingInstruments.addAll(mPendingAutofillInstruments);
+
+        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;
+            }
+        }
+
         // The list of payment instruments is ready to display.
         mPaymentMethodsSection = new SectionInformation(PaymentRequestUI.TYPE_PAYMENT_METHODS,
-                mFirstCompletePendingInstrument, mPendingInstruments);
+                selection, mPendingInstruments);
+
         mPendingInstruments.clear();
+        mPendingInstruments = null;
 
         // UI has requested the full list of payment instruments. Provide it now.
         if (mPaymentInformationCallback != null) providePaymentInformation();
     }
 
-    private void checkForCompletePaymentInstrument(PaymentInstrument instrument, int index) {
-        boolean isComplete = true;
+    /**
+     * Saves the given instrument in either "autofill" or "non-autofill" list. The separation
+     * enables placing autofill instruments on the bottom of the list.
+     *
+     * Autofill instruments are also checked for completeness. A complete autofill instrument can be
+     * sent to the merchant as-is, without editing first. Such instruments should be displayed
+     * higher in the list.
+     *
+     * @param instrument The instrument to add to either "autofill" or "non-autofill" list.
+     */
+    private void addPendingInstrument(PaymentInstrument instrument) {
         if (instrument instanceof AutofillPaymentInstrument) {
             AutofillPaymentInstrument autofillInstrument = (AutofillPaymentInstrument) instrument;
-            isComplete = mCardEditor.isCardComplete(autofillInstrument.getCard());
-            if (isComplete) autofillInstrument.setIsComplete();
-        }
-
-        if (isComplete && mFirstCompletePendingInstrument == SectionInformation.NO_SELECTION) {
-            mFirstCompletePendingInstrument = index;
+            if (mCardEditor.isCardComplete(autofillInstrument.getCard())) {
+                autofillInstrument.setIsComplete();
+            }
+            mPendingAutofillInstruments.add(instrument);
+        } else {
+            mPendingInstruments.add(instrument);
         }
     }
 
     /**
      * Called after retrieving instrument details.
      */
     @Override
     public void onInstrumentDetailsReady(String methodName, String stringifiedDetails) {
         PaymentResponse response = new PaymentResponse();
         response.methodName = methodName;
@@ skipping 80 matching lines @@
     private void closeClient() {
         if (mClient != null) mClient.close();
         mClient = null;
     }
 
     @VisibleForTesting
     public static void setObserverForTest(PaymentRequestServiceObserverForTest observerForTest) {
         sObserverForTest = observerForTest;
     }
 }