Rename card 'type' into 'issuer network.'

components/autofill/core/browser/credit_card.cc

 // Copyright 2013 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.
 
 #include "components/autofill/core/browser/credit_card.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 
 #include "base/guid.h"
 #include "base/i18n/time_formatting.h"
 #include "base/i18n/unicodestring.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/validation.h"
@@ skipping 32 matching lines @@
   }
 
   // Try parsing the |year| as a number.
   if (base::StringToInt(year, num))
     return true;
 
   *num = 0;
   return false;
 }
 
-base::string16 TypeForFill(const std::string& type) {
-  if (type == kAmericanExpressCard)
+base::string16 NetworkForFill(const std::string& network) {
+  if (network == kAmericanExpressCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_AMEX);
-  if (type == kDinersCard)
+  if (network == kDinersCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_DINERS);
-  if (type == kDiscoverCard)
+  if (network == kDiscoverCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_DISCOVER);
-  if (type == kJCBCard)
+  if (network == kJCBCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_JCB);
-  if (type == kMasterCard)
+  if (network == kMasterCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_MASTERCARD);
-  if (type == kMirCard)
+  if (network == kMirCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_MIR);
-  if (type == kUnionPay)
+  if (network == kUnionPay)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_UNION_PAY);
-  if (type == kVisaCard)
+  if (network == kVisaCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_VISA);
 
   // If you hit this DCHECK, the above list of cases needs to be updated to
   // include a new card.
-  DCHECK_EQ(kGenericCard, type);
+  DCHECK_EQ(kGenericCard, network);
   return base::string16();
 }
 
 }  // namespace
 
 CreditCard::CreditCard(const std::string& guid, const std::string& origin)
     : AutofillDataModel(guid, origin),
       record_type_(LOCAL_CARD),
-      type_(kGenericCard),
+      network_(kGenericCard),
       expiration_month_(0),
       expiration_year_(0),
       server_status_(OK) {}
 
 CreditCard::CreditCard(RecordType type, const std::string& server_id)
     : CreditCard() {
   DCHECK(type == MASKED_SERVER_CARD || type == FULL_SERVER_CARD);
   record_type_ = type;
   server_id_ = server_id;
 }
 
 CreditCard::CreditCard() : CreditCard(base::GenerateGUID(), std::string()) {}
 
 CreditCard::CreditCard(const CreditCard& credit_card) : CreditCard() {
   operator=(credit_card);
 }
 
 CreditCard::~CreditCard() {}
 
 // static
 const base::string16 CreditCard::StripSeparators(const base::string16& number) {
   base::string16 stripped;
   base::RemoveChars(number, ASCIIToUTF16("- "), &stripped);
   return stripped;
 }
 
 // static
-base::string16 CreditCard::TypeForDisplay(const std::string& type) {
-  if (kGenericCard == type)
+base::string16 CreditCard::NetworkForDisplay(const std::string& network) {
+  if (kGenericCard == network)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_GENERIC);
-  if (kAmericanExpressCard == type)
+  if (kAmericanExpressCard == network)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_AMEX_SHORT);
 
-  return ::autofill::TypeForFill(type);
+  return ::autofill::NetworkForFill(network);
 }
 
 // static
-int CreditCard::IconResourceId(const std::string& type) {
-  if (type == kAmericanExpressCard)
+int CreditCard::IconResourceId(const std::string& network) {
+  if (network == kAmericanExpressCard)
     return IDR_AUTOFILL_CC_AMEX;
-  if (type == kDinersCard)
+  if (network == kDinersCard)
     return IDR_AUTOFILL_CC_DINERS;
-  if (type == kDiscoverCard)
+  if (network == kDiscoverCard)
     return IDR_AUTOFILL_CC_DISCOVER;
-  if (type == kJCBCard)
+  if (network == kJCBCard)
     return IDR_AUTOFILL_CC_JCB;
-  if (type == kMasterCard)
+  if (network == kMasterCard)
     return IDR_AUTOFILL_CC_MASTERCARD;
-  if (type == kMirCard)
+  if (network == kMirCard)
     return IDR_AUTOFILL_CC_MIR;
-  if (type == kUnionPay)
+  if (network == kUnionPay)
     return IDR_AUTOFILL_CC_UNIONPAY;
-  if (type == kVisaCard)
+  if (network == kVisaCard)
     return IDR_AUTOFILL_CC_VISA;
 
   // If you hit this DCHECK, the above list of cases needs to be updated to
   // include a new card.
-  DCHECK_EQ(kGenericCard, type);
+  DCHECK_EQ(kGenericCard, network);
   return IDR_AUTOFILL_CC_GENERIC;
 }
 
 // static
-const char* CreditCard::GetCreditCardType(const base::string16& number) {
+const char* CreditCard::GetCardNetwork(const base::string16& number) {
   // Credit card number specifications taken from:
   // http://en.wikipedia.org/wiki/Credit_card_numbers,
   // http://en.wikipedia.org/wiki/List_of_Issuer_Identification_Numbers,
   // http://www.discovernetwork.com/merchants/images/Merchant_Marketing_PDF.pdf,
   // http://www.regular-expressions.info/creditcard.html,
   // http://developer.ean.com/general_info/Valid_Credit_Card_Types,
   // http://www.bincodes.com/,
   // http://www.fraudpractice.com/FL-binCC.html, and
   // http://www.beachnet.com/~hstiles/cardtype.html
   //
@@ skipping 72 matching lines @@
 
   if (first_four_digits >= 3528 && first_four_digits <= 3589)
     return kJCBCard;
 
   if (first_four_digits == 6011)
     return kDiscoverCard;
 
   return kGenericCard;
 }
 
-void CreditCard::SetTypeForMaskedCard(const char* type) {
+void CreditCard::SetNetworkForMaskedCard(base::StringPiece network) {
   DCHECK_EQ(MASKED_SERVER_CARD, record_type());
-  type_ = type;
+  network_ = network.as_string();
 }
 
 void CreditCard::SetServerStatus(ServerStatus status) {
   DCHECK_NE(LOCAL_CARD, record_type());
   server_status_ = status;
 }
 
 CreditCard::ServerStatus CreditCard::GetServerStatus() const {
   DCHECK_NE(LOCAL_CARD, record_type());
   return server_status_;
@@ skipping 30 matching lines @@
 
     case CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR: {
       base::string16 month = ExpirationMonthAsString();
       base::string16 year = Expiration4DigitYearAsString();
       if (!month.empty() && !year.empty())
         return month + ASCIIToUTF16("/") + year;
       return base::string16();
     }
 
     case CREDIT_CARD_TYPE:
-      return TypeForFill();
+      return NetworkForFill();
 
     case CREDIT_CARD_NUMBER:
       return number_;
 
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store credit card verification codes.
       return base::string16();
 
     default:
       // ComputeDataPresentForArray will hit this repeatedly.
@@ skipping 50 matching lines @@
   }
 }
 
 base::string16 CreditCard::GetInfo(const AutofillType& type,
                                    const std::string& app_locale) const {
   ServerFieldType storable_type = type.GetStorableType();
   if (storable_type == CREDIT_CARD_NUMBER) {
     // Web pages should never actually be filled by a masked server card,
     // but this function is used at the preview stage.
     if (record_type() == MASKED_SERVER_CARD)
-      return TypeAndLastFourDigits();
+      return NetworkAndLastFourDigits();
 
     return StripSeparators(number_);
   }
 
   return GetRawInfo(storable_type);
 }
 
 bool CreditCard::SetInfo(const AutofillType& type,
                          const base::string16& value,
                          const std::string& app_locale) {
@@ skipping 30 matching lines @@
   return pieces.first + pieces.second;
 }
 
 const std::pair<base::string16, base::string16> CreditCard::LabelPieces()
     const {
   base::string16 label;
   // No CC number, return name only.
   if (number().empty())
     return std::make_pair(name_on_card_, base::string16());
 
-  base::string16 obfuscated_cc_number = TypeAndLastFourDigits();
+  base::string16 obfuscated_cc_number = NetworkAndLastFourDigits();
   // No expiration date set.
   if (!expiration_month_ || !expiration_year_)
     return std::make_pair(obfuscated_cc_number, base::string16());
 
   base::string16 formatted_date(ExpirationMonthAsString());
   formatted_date.append(ASCIIToUTF16("/"));
   formatted_date.append(Expiration4DigitYearAsString());
 
   base::string16 separator =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR);
@@ skipping 45 matching lines @@
 base::string16 CreditCard::LastFourDigits() const {
   static const size_t kNumLastDigits = 4;
 
   base::string16 number = StripSeparators(number_);
   if (number.size() <= kNumLastDigits)
     return number;
 
   return number.substr(number.size() - kNumLastDigits, kNumLastDigits);
 }
 
-base::string16 CreditCard::TypeForDisplay() const {
-  return CreditCard::TypeForDisplay(type_);
+base::string16 CreditCard::NetworkForDisplay() const {
+  return CreditCard::NetworkForDisplay(network_);
 }
 
-base::string16 CreditCard::TypeAndLastFourDigits() const {
-  base::string16 type = TypeForDisplay();
+base::string16 CreditCard::NetworkAndLastFourDigits() const {
+  base::string16 network = NetworkForDisplay();
 
   base::string16 digits = LastFourDigits();
   if (digits.empty())
-    return type;
+    return network;
 
   // TODO(estade): i18n?
-  return type + base::string16(kMidlineEllipsis) + digits;
+  return network + base::string16(kMidlineEllipsis) + digits;
 }
 
 base::string16 CreditCard::AbbreviatedExpirationDateForDisplay() const {
   base::string16 month = ExpirationMonthAsString();
   base::string16 year = Expiration2DigitYearAsString();
   return month.empty() || year.empty()
              ? base::string16()
              : l10n_util::GetStringFUTF16(
                    IDS_AUTOFILL_CREDIT_CARD_EXPIRATION_DATE_ABBR, month, year);
 }
 
 void CreditCard::operator=(const CreditCard& credit_card) {
   set_use_count(credit_card.use_count());
   set_use_date(credit_card.use_date());
   set_modification_date(credit_card.modification_date());
 
   if (this == &credit_card)
     return;
 
   record_type_ = credit_card.record_type_;
   number_ = credit_card.number_;
   name_on_card_ = credit_card.name_on_card_;
-  type_ = credit_card.type_;
+  network_ = credit_card.network_;
   expiration_month_ = credit_card.expiration_month_;
   expiration_year_ = credit_card.expiration_year_;
   server_id_ = credit_card.server_id_;
   server_status_ = credit_card.server_status_;
   billing_address_id_ = credit_card.billing_address_id_;
 
   set_guid(credit_card.guid());
   set_origin(credit_card.origin());
 }
 
 base::string16 CreditCard::GetLastUsedDateForDisplay(
     const std::string& app_locale) const {
   bool show_expiration_date =
       ShowExpirationDateInAutofillCreditCardLastUsedDate();
 
-  DCHECK(use_count() > 0);
+  DCHECK_LT(0U, use_count());
   // use_count() is initialized as 1 when the card is just added.
-  if (use_count() == 1) {
+  if (use_count() == 1U) {
     return show_expiration_date
                ? l10n_util::GetStringFUTF16(
                      IDS_AUTOFILL_CREDIT_CARD_EXP_AND_ADDED_DATE,
                      GetInfo(AutofillType(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR),
                              app_locale),
                      base::TimeFormatWithPattern(
                          use_date(), kTimeFormatPatternNoYearShortMonthDate))
                : l10n_util::GetStringFUTF16(
                      IDS_AUTOFILL_CREDIT_CARD_ADDED_DATE,
                      base::TimeFormatWithPattern(
@@ skipping 120 matching lines @@
   if (number_.empty())
     return true;
 
   return HasSameNumberAs(other);
 }
 
 bool CreditCard::HasSameNumberAs(const CreditCard& other) const {
   // For masked cards, this is the best we can do to compare card numbers.
   if (record_type() == MASKED_SERVER_CARD ||
       other.record_type() == MASKED_SERVER_CARD) {
-    return TypeAndLastFourDigits() == other.TypeAndLastFourDigits();
+    return NetworkAndLastFourDigits() == other.NetworkAndLastFourDigits();
   }
 
   return StripSeparators(number_) == StripSeparators(other.number_);
 }
 
 bool CreditCard::operator==(const CreditCard& credit_card) const {
   return guid() == credit_card.guid() &&
          origin() == credit_card.origin() &&
          Compare(credit_card) == 0;
 }
@@ skipping 100 matching lines @@
 
   base::string16 month = base::IntToString16(expiration_month_);
   if (expiration_month_ >= 10)
     return month;
 
   base::string16 zero = ASCIIToUTF16("0");
   zero.append(month);
   return zero;
 }
 
-base::string16 CreditCard::TypeForFill() const {
-  return ::autofill::TypeForFill(type_);
+base::string16 CreditCard::NetworkForFill() const {
+  return ::autofill::NetworkForFill(network_);
 }
 
 base::string16 CreditCard::Expiration4DigitYearAsString() const {
   if (expiration_year_ == 0)
     return base::string16();
 
   return base::IntToString16(Expiration4DigitYear());
 }
 
 base::string16 CreditCard::Expiration2DigitYearAsString() const {
   if (expiration_year_ == 0)
     return base::string16();
 
   return base::IntToString16(Expiration2DigitYear());
 }
 
 void CreditCard::SetNumber(const base::string16& number) {
   number_ = number;
 
   // Set the type based on the card number, but only for full numbers, not
   // when we have masked cards from the server (last 4 digits).
   if (record_type_ != MASKED_SERVER_CARD)
-    type_ = GetCreditCardType(StripSeparators(number_));
+    network_ = GetCardNetwork(StripSeparators(number_));
 }
 
 void CreditCard::RecordAndLogUse() {
   UMA_HISTOGRAM_COUNTS_1000("Autofill.DaysSinceLastUse.CreditCard",
                             (AutofillClock::Now() - use_date()).InDays());
   RecordUse();
 }
 
 // static
 bool CreditCard::ConvertMonth(const base::string16& month,
@@ skipping 79 matching lines @@
 const char kDinersCard[] = "dinersCC";
 const char kDiscoverCard[] = "discoverCC";
 const char kGenericCard[] = "genericCC";
 const char kJCBCard[] = "jcbCC";
 const char kMasterCard[] = "masterCardCC";
 const char kMirCard[] = "mirCC";
 const char kUnionPay[] = "unionPayCC";
 const char kVisaCard[] = "visaCC";
 
 }  // namespace autofill