Billing address not required for 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.content.Intent;
 import android.graphics.Bitmap;
 import android.os.Handler;
@@ skipping 165 matching lines @@
     /** 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 canMakePayment()
-     * to the list of the payment methods that were been queried. Used for throttling the usage of
+     * to the list of the payment methods that were being 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, CanMakePaymentQuery> sCanMakePaymentQueries;
 
     /** Monitors changes in the TabModelSelector. */
     private final TabModelSelectorObserver mSelectorObserver = new EmptyTabModelSelectorObserver() {
         @Override
         public void onTabModelSelected(TabModel newModel, TabModel oldModel) {
             onDismiss();
@@ skipping 64 matching lines @@
     private boolean mPaymentAppRunning;
     private boolean mMerchantSupportsAutofillPaymentInstruments;
     private ContactEditor mContactEditor;
     private boolean mHasRecordedAbortReason;
     private boolean mQueriedCanMakePayment;
     private CurrencyStringFormatter mFormatter;
 
     /** True if any of the requested payment methods are supported. */
     private boolean mArePaymentMethodsSupported;
 
+    /**
+     * True after at least one usable payment instrument has been found. Should be read only after
+     * all payment apps have been queried.
+     */
+    private boolean mCanMakePayment;
+
     /** 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.
      */
     public PaymentRequestImpl(Activity context, WebContents webContents) {
@@ skipping 886 matching lines @@
             }
             return;
         }
 
         if (query.getPreviousResponse() != null) {
             respondCanMakePaymentQuery(query.getPreviousResponse().booleanValue());
             return;
         }
 
         query.addObserver(this);
-        if (mPendingApps.isEmpty() && mPendingInstruments.isEmpty()) {
-            query.setResponse(mPaymentMethodsSection != null
-                    && mPaymentMethodsSection.getSelectedItem() != null);
-        }
+        if (isFinishedQueryingPaymentApps()) query.setResponse(mCanMakePayment);
     }
 
     private void respondCanMakePaymentQuery(boolean response) {
         mClient.onCanMakePayment(response ? CanMakePaymentQueryResult.CAN_MAKE_PAYMENT
                 : CanMakePaymentQueryResult.CANNOT_MAKE_PAYMENT);
         if (sObserverForTest != null) {
             sObserverForTest.onPaymentRequestServiceCanMakePaymentQueryResponded();
         }
     }
 
@@ skipping 42 matching lines @@
                 }
             }
         }
 
         // Some payment apps still have not responded. Continue waiting for them.
         if (!mPendingApps.isEmpty()) return;
 
         if (disconnectIfNoPaymentMethodsSupported()) return;
 
         // Load the validation rules for each unique region code in the credit card billing
-        // addresses.
+        // addresses and check for validity.
         Set<String> uniqueCountryCodes = new HashSet<>();
         for (int i = 0; i < mPendingAutofillInstruments.size(); ++i) {
             assert mPendingAutofillInstruments.get(i) instanceof AutofillPaymentInstrument;
+            AutofillPaymentInstrument creditCard =
+                    (AutofillPaymentInstrument) mPendingAutofillInstruments.get(i);
 
-            String countryCode = AutofillAddress
-                    .getCountryCode(((AutofillPaymentInstrument) mPendingAutofillInstruments.get(
-                            i)).getBillingAddress());
+            String countryCode = AutofillAddress.getCountryCode(creditCard.getBillingAddress());
             if (!uniqueCountryCodes.contains(countryCode)) {
                 uniqueCountryCodes.add(countryCode);
                 PersonalDataManager.getInstance().loadRulesForRegion(countryCode);
             }
+
+            // If there's a card on file with a valid number and a name, then
+            // PaymentRequest.canMakePayment() returns true.
+            mCanMakePayment |= creditCard.isValid();
         }
 
         // List order:
         // > Non-autofill instruments.
         // > 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();
 
-        // Pre-select the first instrument on the list, if it is complete.
+        // Possibly pre-select the first instrument on the list.
         int selection = SectionInformation.NO_SELECTION;
         if (!mPendingInstruments.isEmpty()) {
             PaymentInstrument first = mPendingInstruments.get(0);
-            if (!(first instanceof AutofillPaymentInstrument)
-                    || ((AutofillPaymentInstrument) first).isComplete()) {
+            if (first instanceof AutofillPaymentInstrument) {
+                AutofillPaymentInstrument creditCard = (AutofillPaymentInstrument) first;
+                if (creditCard.isComplete()) selection = 0;
+            } else {
+                // If a payment app is available, then PaymentRequest.canMakePayment() returns true.
+                mCanMakePayment = true;
                 selection = 0;
             }
         }
 
         CanMakePaymentQuery query = sCanMakePaymentQueries.get(mOrigin);
-        if (query != null) query.setResponse(selection == 0);
+        if (query != null) query.setResponse(mCanMakePayment);
 
         // The list of payment instruments is ready to display.
         mPaymentMethodsSection = new SectionInformation(PaymentRequestUI.TYPE_PAYMENT_METHODS,
                 selection, mPendingInstruments);
 
         mPendingInstruments.clear();
 
         updateInstrumentModifiedTotals();
 
         // 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() {
-        if (mPendingApps == null || !mPendingApps.isEmpty() || !mPendingInstruments.isEmpty()) {
-            // Waiting for pending apps and instruments.
-            return false;
-        }
+        if (!isFinishedQueryingPaymentApps()) return false;
 
         boolean foundPaymentMethods = mPaymentMethodsSection != null
                 && !mPaymentMethodsSection.isEmpty();
         boolean userCanAddCreditCard = mMerchantSupportsAutofillPaymentInstruments
                 && !ChromeFeatureList.isEnabled(ChromeFeatureList.NO_CREDIT_CARD_ABORT);
 
         if (!mArePaymentMethodsSupported
                 || (getIsShowing() && !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();
             return true;
         }
 
         return false;
     }
 
+    /** @return True after payment apps have been queried. */
+    private boolean isFinishedQueryingPaymentApps() {
+        return mPendingApps != null && mPendingApps.isEmpty() && mPendingInstruments.isEmpty();
+    }
+
     /**
      * Saves the given instrument in either "autofill" or "non-autofill" list. The separation
      * enables placing autofill instruments on the bottom of the list.
      *
      * @param instrument The instrument to add to either "autofill" or "non-autofill" list.
      */
     private void addPendingInstrument(PaymentInstrument instrument) {
         if (instrument instanceof AutofillPaymentInstrument) {
             mPendingAutofillInstruments.add(instrument);
         } else {
@@ skipping 149 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");
         }
     }
 }