Convert string16 -> base::string16 in components/

components/autofill/browser/personal_data_manager.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/personal_data_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
@@ skipping 14 matching lines @@
 #include "components/autofill/browser/validation.h"
 #include "components/autofill/common/autofill_pref_names.h"
 #include "components/user_prefs/user_prefs.h"
 #include "components/webdata/autofill/autofill_webdata_service.h"
 #include "content/public/browser/browser_context.h"
 
 using content::BrowserContext;
 
 namespace {
 
-const string16::value_type kCreditCardPrefix[] = {'*', 0};
+const base::string16::value_type kCreditCardPrefix[] = {'*', 0};
 
 template<typename T>
 class FormGroupMatchesByGUIDFunctor {
  public:
   explicit FormGroupMatchesByGUIDFunctor(const std::string& guid)
       : guid_(guid) {
   }
 
   bool operator()(const T& form_group) {
     return form_group.guid() == guid_;
@@ skipping 57 matching lines @@
   if (country.requires_zip() && profile.GetRawInfo(ADDRESS_HOME_ZIP).empty())
     return false;
 
   return true;
 }
 
 // Return true if the |field_type| and |value| are valid within the context
 // of importing a form.
 bool IsValidFieldTypeAndValue(const std::set<AutofillFieldType>& types_seen,
                               AutofillFieldType field_type,
-                              const string16& value) {
+                              const base::string16& value) {
   // Abandon the import if two fields of the same type are encountered.
   // This indicates ambiguous data or miscategorization of types.
   // Make an exception for PHONE_HOME_NUMBER however as both prefix and
   // suffix are stored against this type, and for EMAIL_ADDRESS because it is
   // common to see second 'confirm email address' fields on forms.
   if (types_seen.count(field_type) && field_type != PHONE_HOME_NUMBER &&
       field_type != EMAIL_ADDRESS)
     return false;
 
   // Abandon the import if an email address value shows up in a field that is
@@ skipping 110 matching lines @@
 
   // Detect and discard forms with multiple fields of the same type.
   std::set<AutofillFieldType> types_seen;
 
   // We only set complete phone, so aggregate phone parts in these vars and set
   // complete at the end.
   PhoneNumber::PhoneCombineHelper home;
 
   for (size_t i = 0; i < form.field_count(); ++i) {
     const AutofillField* field = form.field(i);
-    string16 value = CollapseWhitespace(field->value, false);
+    base::string16 value = CollapseWhitespace(field->value, false);
 
     // If we don't know the type of the field, or the user hasn't entered any
     // information into the field, then skip it.
     if (!field->IsFieldFillable() || value.empty())
       continue;
 
     AutofillFieldType field_type = field->type();
     FieldTypeGroup group(AutofillType(field_type).group());
 
     // There can be multiple email fields (e.g. in the case of 'confirm email'
@@ skipping 38 matching lines @@
           !value.empty() &&
           imported_profile->GetRawInfo(ADDRESS_HOME_COUNTRY).empty()) {
         imported_profile.reset();
         break;
       }
     }
   }
 
   // Construct the phone number. Reject the profile if the number is invalid.
   if (imported_profile.get() && !home.IsEmpty()) {
-    string16 constructed_number;
+    base::string16 constructed_number;
     if (!home.ParseNumber(*imported_profile, app_locale_,
                           &constructed_number) ||
         !imported_profile->SetInfo(PHONE_HOME_WHOLE_NUMBER, constructed_number,
                                    app_locale_)) {
       imported_profile.reset();
     }
   }
 
   // Reject the profile if minimum address and validation requirements are not
   // met.
@@ skipping 228 matching lines @@
   return credit_cards_.get();
 }
 
 void PersonalDataManager::Refresh() {
   LoadProfiles();
   LoadCreditCards();
 }
 
 void PersonalDataManager::GetProfileSuggestions(
     AutofillFieldType type,
-    const string16& field_contents,
+    const base::string16& field_contents,
     bool field_is_autofilled,
     std::vector<AutofillFieldType> other_field_types,
-    std::vector<string16>* values,
-    std::vector<string16>* labels,
-    std::vector<string16>* icons,
+    std::vector<base::string16>* values,
+    std::vector<base::string16>* labels,
+    std::vector<base::string16>* icons,
     std::vector<GUIDPair>* guid_pairs) {
   values->clear();
   labels->clear();
   icons->clear();
   guid_pairs->clear();
 
   const std::vector<AutofillProfile*>& profiles = GetProfiles();
   std::vector<AutofillProfile*> matched_profiles;
   for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     AutofillProfile* profile = *iter;
 
     // The value of the stored data for this field type in the |profile|.
-    std::vector<string16> multi_values;
+    std::vector<base::string16> multi_values;
     profile->GetMultiInfo(type, app_locale_, &multi_values);
 
     for (size_t i = 0; i < multi_values.size(); ++i) {
       if (!field_is_autofilled) {
         // Suggest data that starts with what the user has typed.
         if (!multi_values[i].empty() &&
             StartsWith(multi_values[i], field_contents, false)) {
           matched_profiles.push_back(profile);
           values->push_back(multi_values[i]);
           guid_pairs->push_back(GUIDPair(profile->guid(), i));
         }
       } else {
         if (multi_values[i].empty())
           continue;
 
-        string16 profile_value_lower_case(
+        base::string16 profile_value_lower_case(
             StringToLowerASCII(multi_values[i]));
-        string16 field_value_lower_case(StringToLowerASCII(field_contents));
+        base::string16 field_value_lower_case(
+            StringToLowerASCII(field_contents));
         // Phone numbers could be split in US forms, so field value could be
         // either prefix or suffix of the phone.
         bool matched_phones = false;
         if (type == PHONE_HOME_NUMBER && !field_value_lower_case.empty() &&
             (profile_value_lower_case.find(field_value_lower_case) !=
-             string16::npos)) {
+             base::string16::npos)) {
           matched_phones = true;
         }
 
         // Suggest variants of the profile that's already been filled in.
         if (matched_phones ||
             profile_value_lower_case == field_value_lower_case) {
           for (size_t j = 0; j < multi_values.size(); ++j) {
             if (!multi_values[j].empty()) {
               values->push_back(multi_values[j]);
               guid_pairs->push_back(GUIDPair(profile->guid(), j));
@@ skipping 16 matching lines @@
     // No sub-labels for previously filled fields.
     labels->resize(values->size());
   }
 
   // No icons for profile suggestions.
   icons->resize(values->size());
 }
 
 void PersonalDataManager::GetCreditCardSuggestions(
     AutofillFieldType type,
-    const string16& field_contents,
-    std::vector<string16>* values,
-    std::vector<string16>* labels,
-    std::vector<string16>* icons,
+    const base::string16& field_contents,
+    std::vector<base::string16>* values,
+    std::vector<base::string16>* labels,
+    std::vector<base::string16>* icons,
     std::vector<GUIDPair>* guid_pairs) {
   values->clear();
   labels->clear();
   icons->clear();
   guid_pairs->clear();
 
   for (std::vector<CreditCard*>::const_iterator iter = credit_cards().begin();
        iter != credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
-    string16 creditcard_field_value = credit_card->GetInfo(type, app_locale_);
+    base::string16 creditcard_field_value =
+        credit_card->GetInfo(type, app_locale_);
     if (!creditcard_field_value.empty() &&
         StartsWith(creditcard_field_value, field_contents, false)) {
       if (type == CREDIT_CARD_NUMBER)
         creditcard_field_value = credit_card->ObfuscatedNumber();
 
-      string16 label;
+      base::string16 label;
       if (credit_card->number().empty()) {
         // If there is no CC number, return name to show something.
         label = credit_card->GetInfo(CREDIT_CARD_NAME, app_locale_);
       } else {
         label = kCreditCardPrefix;
         label.append(credit_card->LastFourDigits());
       }
 
       values->push_back(creditcard_field_value);
       labels->push_back(label);
       icons->push_back(UTF8ToUTF16(credit_card->type()));
       guid_pairs->push_back(GUIDPair(credit_card->guid(), 0));
     }
   }
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
   return components::UserPrefs::Get(browser_context_)->GetBoolean(
       prefs::kAutofillEnabled);
 }
 
 // static
 bool PersonalDataManager::IsValidLearnableProfile(
     const AutofillProfile& profile,
     const std::string& app_locale) {
   if (!IsMinimumAddress(profile, app_locale))
     return false;
 
-  string16 email = profile.GetRawInfo(EMAIL_ADDRESS);
+  base::string16 email = profile.GetRawInfo(EMAIL_ADDRESS);
   if (!email.empty() && !autofill::IsValidEmailAddress(email))
     return false;
 
   // Reject profiles with invalid US state information.
-  string16 state = profile.GetRawInfo(ADDRESS_HOME_STATE);
+  base::string16 state = profile.GetRawInfo(ADDRESS_HOME_STATE);
   if (profile.GetRawInfo(ADDRESS_HOME_COUNTRY) == ASCIIToUTF16("US") &&
       !state.empty() && !FormGroup::IsValidState(state)) {
     return false;
   }
 
   // Reject profiles with invalid US zip information.
-  string16 zip = profile.GetRawInfo(ADDRESS_HOME_ZIP);
+  base::string16 zip = profile.GetRawInfo(ADDRESS_HOME_ZIP);
   if (profile.GetRawInfo(ADDRESS_HOME_COUNTRY) == ASCIIToUTF16("US") &&
       !zip.empty() && !autofill::IsValidZip(zip))
     return false;
 
   return true;
 }
 
 // static
 bool PersonalDataManager::MergeProfile(
     const AutofillProfile& profile,
@@ skipping 294 matching lines @@
 
 void PersonalDataManager::set_metric_logger(
     const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 void PersonalDataManager::set_browser_context(
     content::BrowserContext* context) {
   browser_context_ = context;
 }