Billing address not required for canMakePayment().

chrome/android/java/src/org/chromium/chrome/browser/payments/AutofillPaymentInstrument.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.content.Context;
 import android.os.Handler;
 import android.text.TextUtils;
 import android.util.JsonWriter;
@@ skipping 24 matching lines @@
 public class AutofillPaymentInstrument extends PaymentInstrument
         implements FullCardRequestDelegate, NormalizedAddressRequestDelegate {
     private final Context mContext;
     private final WebContents mWebContents;
     private CreditCard mCard;
     private String mSecurityCode;
     @Nullable private AutofillProfile mBillingAddress;
     @Nullable private InstrumentDetailsCallback mCallback;
     private boolean mIsWaitingForBillingNormalization;
     private boolean mIsWaitingForFullCardDetails;
+    private boolean mHasValidNumberAndName;
 
     /**
      * Builds a payment instrument for the given credit card.
      *
      * @param context        The application context.
      * @param webContents    The web contents where PaymentRequest was invoked.
      * @param card           The autofill card that can be used for payment.
      * @param billingAddress The billing address for the card.
      */
     public AutofillPaymentInstrument(Context context, WebContents webContents, CreditCard card,
@@ skipping 18 matching lines @@
         return result;
     }
 
     @Override
     public void invokePaymentApp(String unusedMerchantName, String unusedOrigin,
             PaymentItem unusedTotal, List<PaymentItem> unusedCart,
             Map<String, PaymentMethodData> unusedMethodData,
             InstrumentDetailsCallback callback) {
         // The billing address should never be null for a credit card at this point.
         assert mBillingAddress != null;
+        assert AutofillAddress.checkAddressCompletionStatus(mBillingAddress)
+                == AutofillAddress.COMPLETE;
         assert mIsComplete;
+        assert mHasValidNumberAndName;
         assert mCallback == null;
         mCallback = callback;
 
         mIsWaitingForBillingNormalization = true;
         mIsWaitingForFullCardDetails = true;
 
         // Start the billing address normalization.
         PersonalDataManager.getInstance().normalizeAddress(
                 mBillingAddress.getGUID(), AutofillAddress.getCountryCode(mBillingAddress), this);
 
@@ skipping 109 matching lines @@
 
     @Override
     public void onFullCardError() {
         mCallback.onInstrumentDetailsError();
         mCallback = null;
     }
 
     @Override
     public void dismissInstrument() {}
 
-    /** @return Whether the card is complete and ready to be sent to the merchant as-is. */
+    /**
+     * @return Whether the card is complete and ready to be sent to the merchant as-is. If true,
+     * this card has a valid card number, a non-empty name on card, and a complete billing address.
+     */
     public boolean isComplete() {
         return mIsComplete;
     }
 
     /**
+     * @return Whether the card number is valid and name on card is non-empty. Billing address is
+     * not taken into consideration.
+     */
+    public boolean isValid() {
+        return mHasValidNumberAndName;
+    }
+
+    /**
      * Updates the instrument and marks it "complete." Called after the user has edited this
      * instrument.
      *
      * @param card           The new credit card to use. The GUID should not change.
      * @param billingAddress The billing address for the card. The GUID should match the billing
      *                       address ID of the new card to use.
      */
     public void completeInstrument(CreditCard card, AutofillProfile billingAddress) {
         assert card != null;
         assert billingAddress != null;
         assert card.getBillingAddressId() != null;
         assert card.getBillingAddressId().equals(billingAddress.getGUID());
         assert card.getIssuerIconDrawableId() != 0;
         assert AutofillAddress.checkAddressCompletionStatus(billingAddress)
                 == AutofillAddress.COMPLETE;
 
         mCard = card;
         mBillingAddress = billingAddress;
         updateIdentifierLabelsAndIcon(card.getGUID(), card.getObfuscatedNumber(), card.getName(),
                 null, ApiCompatibilityUtils.getDrawable(
                               mContext.getResources(), card.getIssuerIconDrawableId()));
         checkAndUpateCardCompleteness();
         assert mIsComplete;
+        assert mHasValidNumberAndName;
     }
 
     /**
      * Checks whether card is complete, i.e., can be sent to the merchant as-is without editing
      * first. And updates edit message, edit title and complete status.
      *
-     * For both local and server cards, verifies that the billing address is complete. For local
+     * For both local and server cards, verifies that the billing address is present. For local
      * cards also verifies that the card number is valid and the name on card is not empty.
      *
+     * Does not check that the billing address has all of the required fields. This is done
+     * elsewhere to filter out such billing addresses entirely.
+     *
      * Does not check the expiration date. If the card is expired, the user has the opportunity
      * update the expiration date when providing their CVC in the card unmask dialog.
      *
      * Does not check that the card type is accepted by the merchant. This is done elsewhere to
      * filter out such cards from view entirely.
      */
     private void checkAndUpateCardCompleteness() {
         int editMessageResId = 0; // Zero is the invalid resource Id.
         int editTitleResId = R.string.payments_edit_card;
         int invalidFieldsCount = 0;
 
         if (mBillingAddress == null) {
             editMessageResId = R.string.payments_billing_address_required;
             editTitleResId = R.string.payments_add_billing_address;
             invalidFieldsCount++;
         }
 
+        mHasValidNumberAndName = true;
         if (mCard.getIsLocal()) {
             if (TextUtils.isEmpty(mCard.getName())) {
+                mHasValidNumberAndName = false;
                 editMessageResId = R.string.payments_name_on_card_required;
                 editTitleResId = R.string.payments_add_name_on_card;
                 invalidFieldsCount++;
             }
 
             if (PersonalDataManager.getInstance().getBasicCardPaymentType(
                         mCard.getNumber().toString(), true)
                     == null) {
+                mHasValidNumberAndName = false;
                 editMessageResId = R.string.payments_card_number_invalid;
                 editTitleResId = R.string.payments_add_valid_card_number;
                 invalidFieldsCount++;
             }
         }
 
         if (invalidFieldsCount > 1) {
             editMessageResId = R.string.payments_more_information_required;
             editTitleResId = R.string.payments_add_more_information;
         }
 
         mEditMessage = editMessageResId == 0 ? null : mContext.getString(editMessageResId);
         mEditTitle = mContext.getString(editTitleResId);
         mIsComplete = mEditMessage == null;
     }
 
     /** @return The credit card represented by this payment instrument. */
     public CreditCard getCard() {
         return mCard;
     }
 
     /** @return The billing address associated with this credit card. */
     public AutofillProfile getBillingAddress() {
         return mBillingAddress;
     }
 }