Rename card 'type' into 'issuer network.'

chrome/android/java/src/org/chromium/chrome/browser/payments/CardEditor.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.os.AsyncTask;
 import android.os.Handler;
 import android.text.SpannableStringBuilder;
 import android.text.TextUtils;
@@ skipping 33 matching lines @@
 
 import javax.annotation.Nullable;
 
 /**
  * A credit card editor. Can be used for editing both local and server credit cards. Everything in
  * local cards can be edited. For server cards, only the billing address is editable.
  */
 public class CardEditor extends EditorBase<AutofillPaymentInstrument>
         implements CreditCardScanner.Delegate {
     /** Description of a card type. */
-    private static class CardTypeInfo {
-        /** The identifier for the drawable resource of the card type, e.g., R.drawable.pr_visa. */
+    private static class CardIssuerNetwork {
+        /**
+         * The identifier for the drawable resource of the card issuer network, e.g.,
+         * R.drawable.pr_visa.
+         */
         public final int icon;
 
         /**
          * The identifier for the localized description string for accessibility, e.g.,
          * R.string.autofill_cc_visa.
          */
         public final int description;
 
         /**
-         * Builds a description of a card type.
+         * Builds a description of a card issuer network.
          *
-         * @param icon        The identifier for the drawable resource of the card type.
+         * @param icon        The identifier for the drawable resource of the card issuer network.
          * @param description The identifier for the localized description string for accessibility.
          */
-        public CardTypeInfo(int icon, int description) {
+        public CardIssuerNetwork(int icon, int description) {
             this.icon = icon;
             this.description = description;
         }
     }
 
     /** The support credit card names. */
     private static final String AMEX = "amex";
     private static final String DINERS = "diners";
     private static final String DISCOVER = "discover";
     private static final String JCB = "jcb";
@@ skipping 21 matching lines @@
     /** A map of GUIDs of the incomplete profiles to their edit required message resource Ids. */
     private final Map<String, Integer> mIncompleteProfilesForBillingAddress;
 
     /** Used for verifying billing address completeness and also editing billing addresses. */
     private final AddressEditor mAddressEditor;
 
     /** An optional observer used by tests. */
     @Nullable private final PaymentRequestServiceObserverForTest mObserverForTest;
 
     /**
-     * A mapping from all card types recognized in Chrome to information about these card types. The
-     * card types (e.g., "visa") are defined in:
+     * A mapping from all card issuer networks recognized in Chrome to information about these
+     * networks. The networks (e.g., "visa") are defined in:
      * https://w3c.github.io/webpayments-methods-card/#method-id
      */
-    private final Map<String, CardTypeInfo> mCardTypes;
+    private final Map<String, CardIssuerNetwork> mCardIssuerNetworks;
 
     /**
-     * The card types accepted by the merchant website. This is a subset of recognized cards. Used
-     * in the validator.
+     * The issuer networks accepted by the merchant website. This is a subset of recognized cards.
+     * Used in the validator.
      */
-    private final Set<String> mAcceptedCardTypes;
+    private final Set<String> mAcceptedIssuerNetworks;
 
     /**
-     * The card types accepted by the merchant website that should have "basic-card" as the payment
-     * method. This is a subset of the accepted card types. Used when creating the complete payment
-     * instrument.
+     * The issuer networks accepted by the merchant website that should have "basic-card" as the
+     * payment method. This is a subset of the accepted issuer networks. Used when creating the
+     * complete payment instrument.
      */
-    private final Set<String> mAcceptedBasicCardTypes;
+    private final Set<String> mAcceptedBasicCardIssuerNetworks;
 
     /**
-     * The information about the accepted card types. Used in the editor as a hint to the user about
-     * the valid card types. This is important to keep in a list, because the display order matters.
+     * The information about the accepted card issuer networks. Used in the editor as a hint to the
+     * user about the valid card issuer networks. This is important to keep in a list, because the
+     * display order matters.
      */
-    private final List<CardTypeInfo> mAcceptedCardTypeInfos;
+    private final List<CardIssuerNetwork> mAcceptedCardIssuerNetworks;
 
     private final Handler mHandler;
     private final EditorFieldValidator mCardNumberValidator;
     private final EditorValueIconGenerator mCardIconGenerator;
     private final AsyncTask<Void, Void, Calendar> mCalendar;
 
     @Nullable private EditorFieldModel mIconHint;
     @Nullable private EditorFieldModel mNumberField;
     @Nullable private EditorFieldModel mNameField;
     @Nullable private EditorFieldModel mMonthField;
@@ skipping 52 matching lines @@
                 boolean isAComplete = AutofillAddress.checkAddressCompletionStatus(
                                               a, AutofillAddress.NORMAL_COMPLETENESS_CHECK)
                         == AutofillAddress.COMPLETE;
                 boolean isBComplete = AutofillAddress.checkAddressCompletionStatus(
                                               b, AutofillAddress.NORMAL_COMPLETENESS_CHECK)
                         == AutofillAddress.COMPLETE;
                 return ApiCompatibilityUtils.compareBoolean(isBComplete, isAComplete);
             }
         });
 
-        mCardTypes = new HashMap<>();
-        mCardTypes.put(AMEX, new CardTypeInfo(R.drawable.pr_amex, R.string.autofill_cc_amex));
-        mCardTypes.put(
-                DINERS, new CardTypeInfo(R.drawable.pr_dinersclub, R.string.autofill_cc_diners));
-        mCardTypes.put(
-                DISCOVER, new CardTypeInfo(R.drawable.pr_discover, R.string.autofill_cc_discover));
-        mCardTypes.put(JCB, new CardTypeInfo(R.drawable.pr_jcb, R.string.autofill_cc_jcb));
-        mCardTypes.put(
-                MASTERCARD, new CardTypeInfo(R.drawable.pr_mc, R.string.autofill_cc_mastercard));
-        mCardTypes.put(MIR, new CardTypeInfo(R.drawable.pr_mir, R.string.autofill_cc_mir));
-        mCardTypes.put(
-                UNIONPAY, new CardTypeInfo(R.drawable.pr_unionpay, R.string.autofill_cc_union_pay));
-        mCardTypes.put(VISA, new CardTypeInfo(R.drawable.pr_visa, R.string.autofill_cc_visa));
+        mCardIssuerNetworks = new HashMap<>();
+        mCardIssuerNetworks.put(
+                AMEX, new CardIssuerNetwork(R.drawable.pr_amex, R.string.autofill_cc_amex));
+        mCardIssuerNetworks.put(DINERS,
+                new CardIssuerNetwork(R.drawable.pr_dinersclub, R.string.autofill_cc_diners));
+        mCardIssuerNetworks.put(DISCOVER,
+                new CardIssuerNetwork(R.drawable.pr_discover, R.string.autofill_cc_discover));
+        mCardIssuerNetworks.put(
+                JCB, new CardIssuerNetwork(R.drawable.pr_jcb, R.string.autofill_cc_jcb));
+        mCardIssuerNetworks.put(MASTERCARD,
+                new CardIssuerNetwork(R.drawable.pr_mc, R.string.autofill_cc_mastercard));
+        mCardIssuerNetworks.put(
+                MIR, new CardIssuerNetwork(R.drawable.pr_mir, R.string.autofill_cc_mir));
+        mCardIssuerNetworks.put(UNIONPAY,
+                new CardIssuerNetwork(R.drawable.pr_unionpay, R.string.autofill_cc_union_pay));
+        mCardIssuerNetworks.put(
+                VISA, new CardIssuerNetwork(R.drawable.pr_visa, R.string.autofill_cc_visa));
 
-        mAcceptedCardTypes = new HashSet<>();
-        mAcceptedBasicCardTypes = new HashSet<>();
-        mAcceptedCardTypeInfos = new ArrayList<>();
+        mAcceptedIssuerNetworks = new HashSet<>();
+        mAcceptedBasicCardIssuerNetworks = new HashSet<>();
+        mAcceptedCardIssuerNetworks = new ArrayList<>();
         mHandler = new Handler();
 
         mCardNumberValidator = new EditorFieldValidator() {
             @Override
             public boolean isValid(@Nullable CharSequence value) {
                 return value != null
-                        && mAcceptedCardTypes.contains(
-                                   PersonalDataManager.getInstance().getBasicCardPaymentType(
+                        && mAcceptedIssuerNetworks.contains(
+                                   PersonalDataManager.getInstance().getBasicCardIssuerNetwork(
                                            value.toString(), true));
             }
 
             @Override
             public boolean isLengthMaximum(@Nullable CharSequence value) {
                 return isCardNumberLengthMaximum(value);
             }
         };
 
         mCardIconGenerator = new EditorValueIconGenerator() {
             @Override
             public int getIconResourceId(@Nullable CharSequence value) {
                 if (value == null) return 0;
-                CardTypeInfo cardTypeInfo =
-                        mCardTypes.get(PersonalDataManager.getInstance().getBasicCardPaymentType(
+                CardIssuerNetwork cardTypeInfo = mCardIssuerNetworks.get(
+                        PersonalDataManager.getInstance().getBasicCardIssuerNetwork(
                                 value.toString(), false));
                 if (cardTypeInfo == null) return 0;
                 return cardTypeInfo.icon;
             }
         };
 
         mCalendar = new AsyncTask<Void, Void, Calendar>() {
             @Override
             protected Calendar doInBackground(Void... unused) {
                 return Calendar.getInstance();
             }
         };
         mCalendar.execute();
     }
 
     private boolean isCardNumberLengthMaximum(@Nullable CharSequence value) {
         if (TextUtils.isEmpty(value)) return false;
-        String cardType =
-                PersonalDataManager.getInstance().getBasicCardPaymentType(value.toString(), false);
+        String cardType = PersonalDataManager.getInstance().getBasicCardIssuerNetwork(
+                value.toString(), false);
         if (TextUtils.isEmpty(cardType)) return false;
 
         // Below maximum values are consistent with the values used to check the validity of the
         // credit card number in autofill::IsValidCreditCardNumber.
         String cardNumber = removeSpaceAndBar(value);
         switch (cardType) {
             case AMEX:
                 return cardNumber.length() == 15;
             case DINERS:
                 return cardNumber.length() == 14;
@@ skipping 11 matching lines @@
 
     /**
      * Adds accepted payment methods to the editor, if they are recognized credit card types.
      *
      * @param data Supported methods and method specific data. Should not be null.
      */
     public void addAcceptedPaymentMethodsIfRecognized(PaymentMethodData data) {
         assert data != null;
         for (int i = 0; i < data.supportedMethods.length; i++) {
             String method = data.supportedMethods[i];
-            if (mCardTypes.containsKey(method)) {
+            if (mCardIssuerNetworks.containsKey(method)) {
                 addAcceptedNetwork(method);
             } else if (AutofillPaymentApp.BASIC_CARD_METHOD_NAME.equals(method)) {
                 Set<String> basicCardNetworks = AutofillPaymentApp.convertBasicCardToNetworks(data);
                 if (basicCardNetworks != null) {
-                    mAcceptedBasicCardTypes.addAll(basicCardNetworks);
+                    mAcceptedBasicCardIssuerNetworks.addAll(basicCardNetworks);
                     for (String network : basicCardNetworks) {
                         addAcceptedNetwork(network);
                     }
                 }
             }
         }
     }
 
     /**
      * Adds a card network to the list of accepted networks.
      *
      * @param network An accepted network. Will be shown in UI only once, regardless of how many
      *                times this method is called.
      */
     private void addAcceptedNetwork(String network) {
-        if (!mAcceptedCardTypes.contains(network)) {
-            mAcceptedCardTypes.add(network);
-            mAcceptedCardTypeInfos.add(mCardTypes.get(network));
+        if (!mAcceptedIssuerNetworks.contains(network)) {
+            mAcceptedIssuerNetworks.add(network);
+            mAcceptedCardIssuerNetworks.add(mCardIssuerNetworks.get(network));
         }
     }
 
     /**
      * Builds and shows an editor model with the following fields for local cards.
      *
      * [ accepted card types hint images     ]
      * [ card number                         ]
      * [ name on card                        ]
      * [ expiration month ][ expiration year ]
@@ skipping 63 matching lines @@
             }
         });
 
         // If the user clicks [Done], save changes on disk, mark the card "complete," and send it
         // back to the caller.
         editor.setDoneCallback(new Runnable() {
             @Override
             public void run() {
                 commitChanges(card, isNewCard);
 
-                String methodName = card.getBasicCardPaymentType();
-                if (mAcceptedBasicCardTypes.contains(methodName)) {
+                String methodName = card.getBasicCardIssuerNetwork();
+                if (mAcceptedBasicCardIssuerNetworks.contains(methodName)) {
                     methodName = AutofillPaymentApp.BASIC_CARD_METHOD_NAME;
                 }
                 assert methodName != null;
 
                 AutofillProfile billingAddress =
                         findTargetProfile(mProfilesForBillingAddress, card.getBillingAddressId());
                 assert billingAddress != null;
 
                 instrument.completeInstrument(card, methodName, billingAddress);
                 callback.onResult(instrument);
@@ skipping 33 matching lines @@
      * [ accepted card types hint images     ]
      * [ card number              [ocr icon] ]
      * [ name on card                        ]
      * [ expiration month ][ expiration year ]
      */
     private void addLocalCardInputs(EditorModel editor, CreditCard card, Calendar calendar) {
         // Local card editor shows a card icon hint.
         if (mIconHint == null) {
             List<Integer> icons = new ArrayList<>();
             List<Integer> descriptions = new ArrayList<>();
-            for (int i = 0; i < mAcceptedCardTypeInfos.size(); i++) {
-                icons.add(mAcceptedCardTypeInfos.get(i).icon);
-                descriptions.add(mAcceptedCardTypeInfos.get(i).description);
+            for (int i = 0; i < mAcceptedCardIssuerNetworks.size(); i++) {
+                icons.add(mAcceptedCardIssuerNetworks.get(i).icon);
+                descriptions.add(mAcceptedCardIssuerNetworks.get(i).description);
             }
             mIconHint = EditorFieldModel.createIconList(
                     mContext.getString(R.string.payments_accepted_cards_label), icons,
                     descriptions);
         }
         editor.addField(mIconHint);
 
         // Card scanner is expensive to query.
         if (mCardScanner == null) {
             mCardScanner = CreditCardScanner.create(mWebContents, this);
@@ skipping 308 matching lines @@
         if (!card.getIsLocal()) {
             pdm.updateServerCardBillingAddress(card);
             return;
         }
 
         card.setNumber(removeSpaceAndBar(mNumberField.getValue()));
         card.setName(mNameField.getValue().toString());
         card.setMonth(mMonthField.getValue().toString());
         card.setYear(mYearField.getValue().toString());
 
-        // Calculate the basic card payment type, obfuscated number, and the icon for this card.
-        // All of these depend on the card number. The type is sent to the merchant website. The
-        // obfuscated number and the icon are displayed in the user interface.
+        // Calculate the basic card issuer network, obfuscated number, and the icon for this card.
+        // All of these depend on the card number. The issuer network is sent to the merchant
+        // website. The obfuscated number and the icon are displayed in the user interface.
         CreditCard displayableCard = pdm.getCreditCardForNumber(card.getNumber());
-        card.setBasicCardPaymentType(displayableCard.getBasicCardPaymentType());
+        card.setBasicCardIssuerNetwork(displayableCard.getBasicCardIssuerNetwork());
         card.setObfuscatedNumber(displayableCard.getObfuscatedNumber());
         card.setIssuerIconDrawableId(displayableCard.getIssuerIconDrawableId());
 
         if (!isNewCard) {
             pdm.setCreditCard(card);
             return;
         }
 
         if (mSaveCardCheckbox != null && mSaveCardCheckbox.isChecked()) {
             card.setGUID(pdm.setCreditCard(card));
@@ skipping 13 matching lines @@
 
         mEditorView.update();
         mIsScanning = false;
     }
 
     @Override
     public void onScanCancelled() {
         mIsScanning = false;
     }
 }