Move StringToLowerASCII to base namespace

components/autofill/core/browser/personal_data_manager.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/personal_data_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
@@ skipping 584 matching lines @@
             (filter.is_null() || filter.Run(*profile))) {
           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;
 
         base::string16 profile_value_lower_case(
-            StringToLowerASCII(multi_values[i]));
+            base::StringToLowerASCII(multi_values[i]));
         base::string16 field_value_lower_case(
-            StringToLowerASCII(field_contents));
+            base::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.GetStorableType() == PHONE_HOME_NUMBER &&
             !field_value_lower_case.empty() &&
             profile_value_lower_case.find(field_value_lower_case) !=
                 base::string16::npos) {
           matched_phones = true;
         }
 
@@ skipping 126 matching lines @@
   std::string guid = new_profile.guid();
 
   // If we have already saved this address, merge in any missing values.
   // Only merge with the first match.
   for (std::vector<AutofillProfile*>::const_iterator iter =
            existing_profiles.begin();
        iter != existing_profiles.end(); ++iter) {
     AutofillProfile* existing_profile = *iter;
     if (!matching_profile_found &&
         !new_profile.PrimaryValue().empty() &&
-        StringToLowerASCII(existing_profile->PrimaryValue()) ==
-            StringToLowerASCII(new_profile.PrimaryValue())) {
+        base::StringToLowerASCII(existing_profile->PrimaryValue()) ==
+            base::StringToLowerASCII(new_profile.PrimaryValue())) {
       // Unverified profiles should always be updated with the newer data,
       // whereas verified profiles should only ever be overwritten by verified
       // data.  If an automatically aggregated profile would overwrite a
       // verified profile, just drop it.
       matching_profile_found = true;
       guid = existing_profile->guid();
       if (!existing_profile->IsVerified() || new_profile.IsVerified())
         existing_profile->OverwriteWithOrAddTo(new_profile, app_locale);
     }
     merged_profiles->push_back(*existing_profile);
   }
 
   // If the new profile was not merged with an existing one, add it to the list.
   if (!matching_profile_found)
     merged_profiles->push_back(new_profile);
 
   return guid;
 }
 
 bool PersonalDataManager::IsCountryOfInterest(const std::string& country_code)
     const {
   DCHECK_EQ(2U, country_code.size());
 
   const std::vector<AutofillProfile*>& profiles = web_profiles();
   std::list<std::string> country_codes;
   for (size_t i = 0; i < profiles.size(); ++i) {
-    country_codes.push_back(StringToLowerASCII(base::UTF16ToASCII(
+    country_codes.push_back(base::StringToLowerASCII(base::UTF16ToASCII(
         profiles[i]->GetRawInfo(ADDRESS_HOME_COUNTRY))));
   }
 
   std::string timezone_country = CountryCodeForCurrentTimezone();
   if (!timezone_country.empty())
-    country_codes.push_back(StringToLowerASCII(timezone_country));
+    country_codes.push_back(base::StringToLowerASCII(timezone_country));
 
   // Only take the locale into consideration if all else fails.
   if (country_codes.empty()) {
-    country_codes.push_back(StringToLowerASCII(
+    country_codes.push_back(base::StringToLowerASCII(
         AutofillCountry::CountryCodeForLocale(app_locale())));
   }
 
   return std::find(country_codes.begin(), country_codes.end(),
-                   StringToLowerASCII(country_code)) != country_codes.end();
+                   base::StringToLowerASCII(country_code)) !=
+                       country_codes.end();
 }
 
 const std::string& PersonalDataManager::GetDefaultCountryCodeForNewAddress()
     const {
   if (default_country_code_.empty())
     default_country_code_ = MostCommonCountryCodeFromProfiles();
 
   // Failing that, guess based on system timezone.
   if (default_country_code_.empty())
     default_country_code_ = CountryCodeForCurrentTimezone();
@@ skipping 294 matching lines @@
   // Populates |auxiliary_profiles_|.
   LoadAuxiliaryProfiles(record_metrics);
 
   profiles_.insert(profiles_.end(), web_profiles_.begin(), web_profiles_.end());
   profiles_.insert(
       profiles_.end(), auxiliary_profiles_.begin(), auxiliary_profiles_.end());
   return profiles_;
 }
 
 }  // namespace autofill