Convert string16 -> base::string16 in components/

components/autofill/browser/credit_card.cc

 // Copyright (c) 2012 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/browser/credit_card.h"
 
 #include <stddef.h>
 
 #include <ostream>
 #include <string>
@@ skipping 20 matching lines @@
 
 namespace {
 
 const char16 kCreditCardObfuscationSymbol = '*';
 
 // This is the maximum obfuscated symbols displayed.
 // It is introduced to avoid rare cases where the credit card number is
 // too large and fills the screen.
 const size_t kMaxObfuscationSize = 20;
 
-std::string GetCreditCardType(const string16& number) {
+std::string GetCreditCardType(const base::string16& number) {
   // Don't check for a specific type if this is not a credit card number.
   if (!autofill::IsValidCreditCardNumber(number))
     return kGenericCard;
 
   // Credit card number specifications taken from:
   // http://en.wikipedia.org/wiki/Credit_card_numbers and
   // http://www.beachnet.com/~hstiles/cardtype.html
   // Card Type              Prefix(es)                      Length
   // ---------------------------------------------------------------
   // Visa                   4                               13,16
@@ skipping 63 matching lines @@
     case 19:
       if (first_four_digits == 6334 || first_four_digits == 6767)
         return kSoloCard;
 
       break;
   }
 
   return kGenericCard;
 }
 
-bool ConvertYear(const string16& year, int* num) {
+bool ConvertYear(const base::string16& year, int* num) {
   // If the |year| is empty, clear the stored value.
   if (year.empty()) {
     *num = 0;
     return true;
   }
 
   // Try parsing the |year| as a number.
   if (base::StringToInt(year, num))
     return true;
 
   *num = 0;
   return false;
 }
 
-bool ConvertMonth(const string16& month,
+bool ConvertMonth(const base::string16& month,
                   const std::string& app_locale,
                   int* num) {
   // If the |month| is empty, clear the stored value.
   if (month.empty()) {
     *num = 0;
     return true;
   }
 
   // Try parsing the |month| as a number.
   if (base::StringToInt(month, num))
     return true;
 
   // If the locale is unknown, give up.
   if (app_locale.empty())
     return false;
 
   // Otherwise, try parsing the |month| as a named month, e.g. "January" or
   // "Jan".
-  string16 lowercased_month = StringToLowerASCII(month);
+  base::string16 lowercased_month = StringToLowerASCII(month);
 
   UErrorCode status = U_ZERO_ERROR;
   icu::Locale locale(app_locale.c_str());
   icu::DateFormatSymbols date_format_symbols(locale, status);
   DCHECK(status == U_ZERO_ERROR || status == U_USING_FALLBACK_WARNING ||
          status == U_USING_DEFAULT_WARNING);
 
   int32_t num_months;
   const icu::UnicodeString* months = date_format_symbols.getMonths(num_months);
   for (int32_t i = 0; i < num_months; ++i) {
-    const string16 icu_month = string16(months[i].getBuffer(),
+    const base::string16 icu_month = base::string16(months[i].getBuffer(),
                                         months[i].length());
     if (lowercased_month == StringToLowerASCII(icu_month)) {
       *num = i + 1;  // Adjust from 0-indexed to 1-indexed.
       return true;
     }
   }
 
   months = date_format_symbols.getShortMonths(num_months);
   for (int32_t i = 0; i < num_months; ++i) {
-    const string16 icu_month = string16(months[i].getBuffer(),
+    const base::string16 icu_month = base::string16(months[i].getBuffer(),
                                         months[i].length());
     if (lowercased_month == StringToLowerASCII(icu_month)) {
       *num = i + 1;  // Adjust from 0-indexed to 1-indexed.
       return true;
     }
   }
 
   *num = 0;
   return false;
 }
@@ skipping 14 matching lines @@
       guid_(base::GenerateGUID()) {
 }
 
 CreditCard::CreditCard(const CreditCard& credit_card) : FormGroup() {
   operator=(credit_card);
 }
 
 CreditCard::~CreditCard() {}
 
 // static
-const string16 CreditCard::StripSeparators(const string16& number) {
+const base::string16 CreditCard::StripSeparators(const base::string16& number) {
   const char16 kSeparators[] = {'-', ' ', '\0'};
-  string16 stripped;
+  base::string16 stripped;
   RemoveChars(number, kSeparators, &stripped);
   return stripped;
 }
 
 // static
-string16 CreditCard::TypeForDisplay(const std::string& type) {
+base::string16 CreditCard::TypeForDisplay(const std::string& type) {
   if (type == kAmericanExpressCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_AMEX);
   if (type == kDinersCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_DINERS);
   if (type == kDiscoverCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_DISCOVER);
   if (type == kJCBCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_JCB);
   if (type == kMasterCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_MASTERCARD);
   if (type == kSoloCard)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_SOLO);
   if (type == 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);
-  return string16();
+  return base::string16();
 }
 
 std::string CreditCard::GetGUID() const {
   return guid();
 }
 
-string16 CreditCard::GetRawInfo(AutofillFieldType type) const {
+base::string16 CreditCard::GetRawInfo(AutofillFieldType type) const {
   switch (type) {
     case CREDIT_CARD_NAME:
       return name_on_card_;
 
     case CREDIT_CARD_EXP_MONTH:
       return ExpirationMonthAsString();
 
     case CREDIT_CARD_EXP_2_DIGIT_YEAR:
       return Expiration2DigitYearAsString();
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return Expiration4DigitYearAsString();
 
     case CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR: {
-      string16 month = ExpirationMonthAsString();
-      string16 year = Expiration2DigitYearAsString();
+      base::string16 month = ExpirationMonthAsString();
+      base::string16 year = Expiration2DigitYearAsString();
       if (!month.empty() && !year.empty())
         return month + ASCIIToUTF16("/") + year;
-      return string16();
+      return base::string16();
     }
 
     case CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR: {
-      string16 month = ExpirationMonthAsString();
-      string16 year = Expiration4DigitYearAsString();
+      base::string16 month = ExpirationMonthAsString();
+      base::string16 year = Expiration4DigitYearAsString();
       if (!month.empty() && !year.empty())
         return month + ASCIIToUTF16("/") + year;
-      return string16();
+      return base::string16();
     }
 
     case CREDIT_CARD_TYPE:
       return TypeForDisplay();
 
     case CREDIT_CARD_NUMBER:
       return number_;
 
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store credit card verification codes.
-      return string16();
+      return base::string16();
 
     default:
       // ComputeDataPresentForArray will hit this repeatedly.
-      return string16();
+      return base::string16();
   }
 }
 
-void CreditCard::SetRawInfo(AutofillFieldType type, const string16& value) {
+void CreditCard::SetRawInfo(AutofillFieldType type,
+                            const base::string16& value) {
   switch (type) {
     case CREDIT_CARD_NAME:
       name_on_card_ = value;
       break;
 
     case CREDIT_CARD_EXP_MONTH:
       SetExpirationMonthFromString(value, std::string());
       break;
 
     case CREDIT_CARD_EXP_2_DIGIT_YEAR:
@@ skipping 26 matching lines @@
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store the credit card verification code.
       break;
 
     default:
       NOTREACHED() << "Attempting to set unknown info-type " << type;
       break;
   }
 }
 
-string16 CreditCard::GetInfo(AutofillFieldType type,
+base::string16 CreditCard::GetInfo(AutofillFieldType type,
                              const std::string& app_locale) const {
   if (type == CREDIT_CARD_NUMBER)
     return StripSeparators(number_);
 
   return GetRawInfo(type);
 }
 
 bool CreditCard::SetInfo(AutofillFieldType type,
-                         const string16& value,
+                         const base::string16& value,
                          const std::string& app_locale) {
   if (type == CREDIT_CARD_NUMBER)
     SetRawInfo(type, StripSeparators(value));
   else if (type == CREDIT_CARD_EXP_MONTH)
     SetExpirationMonthFromString(value, app_locale);
   else
     SetRawInfo(type, value);
 
   return true;
 }
 
-void CreditCard::GetMatchingTypes(const string16& text,
+void CreditCard::GetMatchingTypes(const base::string16& text,
                                   const std::string& app_locale,
                                   FieldTypeSet* matching_types) const {
   FormGroup::GetMatchingTypes(text, app_locale, matching_types);
 
-  string16 card_number = GetInfo(CREDIT_CARD_NUMBER, app_locale);
+  base::string16 card_number = GetInfo(CREDIT_CARD_NUMBER, app_locale);
   if (!card_number.empty() && StripSeparators(text) == card_number)
     matching_types->insert(CREDIT_CARD_NUMBER);
 
   int month;
   if (ConvertMonth(text, app_locale, &month) && month != 0 &&
       month == expiration_month_) {
     matching_types->insert(CREDIT_CARD_EXP_MONTH);
   }
 }
 
-const string16 CreditCard::Label() const {
-  string16 label;
+const base::string16 CreditCard::Label() const {
+  base::string16 label;
   if (number().empty())
     return name_on_card_;  // No CC number, return name only.
 
-  string16 obfuscated_cc_number = ObfuscatedNumber();
+  base::string16 obfuscated_cc_number = ObfuscatedNumber();
   if (!expiration_month_ || !expiration_year_)
     return obfuscated_cc_number;  // No expiration date set.
 
   // TODO(georgey): Internationalize date.
-  string16 formatted_date(ExpirationMonthAsString());
+  base::string16 formatted_date(ExpirationMonthAsString());
   formatted_date.append(ASCIIToUTF16("/"));
   formatted_date.append(Expiration4DigitYearAsString());
 
   label = l10n_util::GetStringFUTF16(IDS_CREDIT_CARD_NUMBER_PREVIEW_FORMAT,
                                      obfuscated_cc_number,
                                      formatted_date);
   return label;
 }
 
-void CreditCard::SetInfoForMonthInputType(const string16& value) {
+void CreditCard::SetInfoForMonthInputType(const base::string16& value) {
   // Check if |text| is "yyyy-mm" format first, and check normal month format.
   if (!autofill::MatchesPattern(value, UTF8ToUTF16("^[0-9]{4}-[0-9]{1,2}$")))
     return;
 
-  std::vector<string16> year_month;
+  std::vector<base::string16> year_month;
   base::SplitString(value, L'-', &year_month);
   DCHECK_EQ((int)year_month.size(), 2);
   int num = 0;
   bool converted = false;
   converted = base::StringToInt(year_month[0], &num);
   DCHECK(converted);
   SetExpirationYear(num);
   converted = base::StringToInt(year_month[1], &num);
   DCHECK(converted);
   SetExpirationMonth(num);
 }
 
-string16 CreditCard::ObfuscatedNumber() const {
+base::string16 CreditCard::ObfuscatedNumber() const {
   // If the number is shorter than four digits, there's no need to obfuscate it.
   if (number_.size() < 4)
     return number_;
 
-  string16 number = StripSeparators(number_);
+  base::string16 number = StripSeparators(number_);
 
   // Avoid making very long obfuscated numbers.
   size_t obfuscated_digits = std::min(kMaxObfuscationSize, number.size() - 4);
-  string16 result(obfuscated_digits, kCreditCardObfuscationSymbol);
+  base::string16 result(obfuscated_digits, kCreditCardObfuscationSymbol);
   return result.append(LastFourDigits());
 }
 
-string16 CreditCard::LastFourDigits() const {
+base::string16 CreditCard::LastFourDigits() const {
   static const size_t kNumLastDigits = 4;
 
-  string16 number = StripSeparators(number_);
+  base::string16 number = StripSeparators(number_);
   if (number.size() < kNumLastDigits)
-    return string16();
+    return base::string16();
 
   return number.substr(number.size() - kNumLastDigits, kNumLastDigits);
 }
 
-string16 CreditCard::TypeForDisplay() const {
+base::string16 CreditCard::TypeForDisplay() const {
   return CreditCard::TypeForDisplay(type_);
 }
 
-string16 CreditCard::TypeAndLastFourDigits() const {
-  string16 type = TypeForDisplay();
+base::string16 CreditCard::TypeAndLastFourDigits() const {
+  base::string16 type = TypeForDisplay();
   // TODO(estade): type may be empty, we probably want to return
   // "Card - 1234" or something in that case.
 
-  string16 digits = LastFourDigits();
+  base::string16 digits = LastFourDigits();
   if (digits.empty())
     return type;
 
   // TODO(estade): i18n.
   return type + ASCIIToUTF16(" - ") + digits;
 }
 
 int CreditCard::IconResourceId() const {
   if (type_ == kAmericanExpressCard)
     return IDR_AUTOFILL_CC_AMEX;
@@ skipping 53 matching lines @@
                                size_t /*variant*/,
                                const std::string& app_locale,
                                FormFieldData* field_data) const {
   DCHECK_EQ(AutofillType::CREDIT_CARD, AutofillType(field.type()).group());
   DCHECK(field_data);
 
   if (field_data->form_control_type == "select-one") {
     FillSelectControl(field.type(), app_locale, field_data);
   } else if (field_data->form_control_type == "month") {
     // HTML5 input="month" consists of year-month.
-    string16 year = GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, app_locale);
-    string16 month = GetInfo(CREDIT_CARD_EXP_MONTH, app_locale);
+    base::string16 year = GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, app_locale);
+    base::string16 month = GetInfo(CREDIT_CARD_EXP_MONTH, app_locale);
     if (!year.empty() && !month.empty()) {
       // Fill the value only if |this| includes both year and month
       // information.
       field_data->value = year + ASCIIToUTF16("-") + month;
     }
   } else {
     field_data->value = GetInfo(field.type(), app_locale);
   }
 }
 
@@ skipping 43 matching lines @@
   supported_types->insert(CREDIT_CARD_NAME);
   supported_types->insert(CREDIT_CARD_NUMBER);
   supported_types->insert(CREDIT_CARD_TYPE);
   supported_types->insert(CREDIT_CARD_EXP_MONTH);
   supported_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
 }
 
-string16 CreditCard::ExpirationMonthAsString() const {
+base::string16 CreditCard::ExpirationMonthAsString() const {
   if (expiration_month_ == 0)
-    return string16();
+    return base::string16();
 
-  string16 month = base::IntToString16(expiration_month_);
+  base::string16 month = base::IntToString16(expiration_month_);
   if (expiration_month_ >= 10)
     return month;
 
-  string16 zero = ASCIIToUTF16("0");
+  base::string16 zero = ASCIIToUTF16("0");
   zero.append(month);
   return zero;
 }
 
-string16 CreditCard::Expiration4DigitYearAsString() const {
+base::string16 CreditCard::Expiration4DigitYearAsString() const {
   if (expiration_year_ == 0)
-    return string16();
+    return base::string16();
 
   return base::IntToString16(Expiration4DigitYear());
 }
 
-string16 CreditCard::Expiration2DigitYearAsString() const {
+base::string16 CreditCard::Expiration2DigitYearAsString() const {
   if (expiration_year_ == 0)
-    return string16();
+    return base::string16();
 
   return base::IntToString16(Expiration2DigitYear());
 }
 
-void CreditCard::SetExpirationMonthFromString(const string16& text,
+void CreditCard::SetExpirationMonthFromString(const base::string16& text,
                                               const std::string& app_locale) {
   int month;
   if (!ConvertMonth(text, app_locale, &month))
     return;
 
   SetExpirationMonth(month);
 }
 
-void CreditCard::SetExpirationYearFromString(const string16& text) {
+void CreditCard::SetExpirationYearFromString(const base::string16& text) {
   int year;
   if (!ConvertYear(text, &year))
     return;
 
   SetExpirationYear(year);
 }
 
-void CreditCard::SetNumber(const string16& number) {
+void CreditCard::SetNumber(const base::string16& number) {
   number_ = number;
   type_ = GetCreditCardType(StripSeparators(number_));
 }
 
 void CreditCard::SetExpirationMonth(int expiration_month) {
   if (expiration_month < 0 || expiration_month > 12)
     return;
 
   expiration_month_ = expiration_month;
 }
@@ skipping 29 matching lines @@
 // webkit/glue. We send these strings to WebKit, which then asks
 // WebKitPlatformSupportImpl to load the image data.
 const char* const kAmericanExpressCard = "americanExpressCC";
 const char* const kDinersCard = "dinersCC";
 const char* const kDiscoverCard = "discoverCC";
 const char* const kGenericCard = "genericCC";
 const char* const kJCBCard = "jcbCC";
 const char* const kMasterCard = "masterCardCC";
 const char* const kSoloCard = "soloCC";
 const char* const kVisaCard = "visaCC";