Convert string16 -> base::string16 in components/

components/autofill/browser/autofill_country.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/autofill_country.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <utility>
@@ skipping 825 matching lines @@
 }
 
 // A singleton class that encapsulates mappings from country names to their
 // corresponding country codes.
 class CountryNames {
  public:
   static CountryNames* GetInstance();
 
   // Returns the country code corresponding to |country|, which should be a
   // country code or country name localized to |locale|.
-  const std::string GetCountryCode(const string16& country,
+  const std::string GetCountryCode(const base::string16& country,
                                    const std::string& locale);
 
  private:
   CountryNames();
   ~CountryNames();
   friend struct DefaultSingletonTraits<CountryNames>;
 
   // Populates |locales_to_localized_names_| with the mapping of country names
   // localized to |locale| to their corresponding country codes.
   void AddLocalizedNamesForLocale(const std::string& locale);
 
   // Interprets |country_name| as a full country name localized to the given
   // |locale| and returns the corresponding country code stored in
   // |locales_to_localized_names_|, or an empty string if there is none.
-  const std::string GetCountryCodeForLocalizedName(const string16& country_name,
-                                                   const std::string& locale);
+  const std::string GetCountryCodeForLocalizedName(
+      const base::string16& country_name,
+      const std::string& locale);
 
   // Returns an ICU collator -- i.e. string comparator -- appropriate for the
   // given |locale|.
   icu::Collator* GetCollatorForLocale(const std::string& locale);
 
   // Returns the ICU sort key corresponding to |str| for the given |collator|.
   // Uses |buffer| as temporary storage, and might resize |buffer| as a side-
   // effect. |buffer_size| should specify the |buffer|'s size, and is updated if
   // the |buffer| is resized.
   const std::string GetSortKey(const icu::Collator& collator,
-                               const string16& str,
+                               const base::string16& str,
                                scoped_ptr<uint8_t[]>* buffer,
                                int32_t* buffer_size) const;
 
   // Maps from common country names, including 2- and 3-letter country codes,
   // to the corresponding 2-letter country codes. The keys are uppercase ASCII
   // strings.
   std::map<std::string, std::string> common_names_;
 
   // The outer map keys are ICU locale identifiers.
   // The inner maps map from localized country names to their corresponding
@@ skipping 36 matching lines @@
   common_names_.insert(std::make_pair("UK", "GB"));
   common_names_.insert(std::make_pair("BRASIL", "BR"));
   common_names_.insert(std::make_pair("DEUTSCHLAND", "DE"));
 }
 
 CountryNames::~CountryNames() {
   STLDeleteContainerPairSecondPointers(collators_.begin(),
                                        collators_.end());
 }
 
-const std::string CountryNames::GetCountryCode(const string16& country,
+const std::string CountryNames::GetCountryCode(const base::string16& country,
                                                const std::string& locale) {
   // First, check common country names, including 2- and 3-letter country codes.
   std::string country_utf8 = UTF16ToUTF8(StringToUpperASCII(country));
   std::map<std::string, std::string>::const_iterator result =
       common_names_.find(country_utf8);
   if (result != common_names_.end())
     return result->second;
 
   // Next, check country names localized to |locale|.
   std::string country_code = GetCountryCodeForLocalizedName(country, locale);
@@ skipping 12 matching lines @@
 
   std::map<std::string, std::string> localized_names;
   const icu::Collator* collator = GetCollatorForLocale(locale);
   int32_t buffer_size = 1000;
   scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
 
   for (CountryDataMap::Iterator it = CountryDataMap::Begin();
        it != CountryDataMap::End();
        ++it) {
     const std::string& country_code = it->first;
-    string16 country_name = l10n_util::GetDisplayNameForCountry(country_code,
-                                                                locale);
+    base::string16 country_name = l10n_util::GetDisplayNameForCountry(
+        country_code, locale);
     std::string sort_key = GetSortKey(*collator,
                                       country_name,
                                       &buffer,
                                       &buffer_size);
 
     localized_names.insert(std::make_pair(sort_key, country_code));
   }
 
   locales_to_localized_names_.insert(std::make_pair(locale, localized_names));
 }
 
 const std::string CountryNames::GetCountryCodeForLocalizedName(
-    const string16& country_name,
+    const base::string16& country_name,
     const std::string& locale) {
   AddLocalizedNamesForLocale(locale);
 
   icu::Collator* collator = GetCollatorForLocale(locale);
 
   // As recommended[1] by ICU, initialize the buffer size to four times the
   // source string length.
   // [1] http://userguide.icu-project.org/collation/api#TOC-Examples
   int32_t buffer_size = country_name.size() * 4;
   scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
@@ skipping 25 matching lines @@
     ignored = U_ZERO_ERROR;
     collator->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, ignored);
 
     collators_.insert(std::make_pair(locale, collator));
   }
 
   return collators_[locale];
 }
 
 const std::string CountryNames::GetSortKey(const icu::Collator& collator,
-                                           const string16& str,
+                                           const base::string16& str,
                                            scoped_ptr<uint8_t[]>* buffer,
                                            int32_t* buffer_size) const {
   DCHECK(buffer);
   DCHECK(buffer_size);
 
   icu::UnicodeString icu_str(str.c_str(), str.length());
   int32_t expected_size = collator.getSortKey(icu_str, buffer->get(),
                                               *buffer_size);
   if (expected_size > *buffer_size) {
     // If there wasn't enough space, grow the buffer and try again.
@@ skipping 54 matching lines @@
   std::string country_code = icu::Locale(likely_locale.c_str()).getCountry();
 
   // Default to the United States if we have no better guess.
   if (CountryDataMap::Find(country_code) == CountryDataMap::End())
     return "US";
 
   return country_code;
 }
 
 // static
-const std::string AutofillCountry::GetCountryCode(const string16& country,
+const std::string AutofillCountry::GetCountryCode(const base::string16& country,
                                                   const std::string& locale) {
   return CountryNames::GetInstance()->GetCountryCode(country, locale);
 }
 
 AutofillCountry::AutofillCountry(const std::string& country_code,
-                                 const string16& name,
-                                 const string16& postal_code_label,
-                                 const string16& state_label)
+                                 const base::string16& name,
+                                 const base::string16& postal_code_label,
+                                 const base::string16& state_label)
     : country_code_(country_code),
       name_(name),
       postal_code_label_(postal_code_label),
       state_label_(state_label) {
 }