Move more uses of string16 to specify base::

ui/base/l10n/l10n_util.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 "ui/base/l10n/l10n_util.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <iterator>
 #include <string>
@@ skipping 235 matching lines @@
   // See crbug.com/230432: CHECK failure in GetUserDataDir().
   return ResourceBundle::GetSharedInstance().LocaleDataPakExists(locale);
 }
 #endif
 
 // On Linux, the text layout engine Pango determines paragraph directionality
 // by looking at the first strongly-directional character in the text. This
 // means text such as "Google Chrome foo bar..." will be layed out LTR even
 // if "foo bar" is RTL. So this function prepends the necessary RLM in such
 // cases.
-void AdjustParagraphDirectionality(string16* paragraph) {
+void AdjustParagraphDirectionality(base::string16* paragraph) {
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   if (base::i18n::IsRTL() &&
       base::i18n::StringContainsStrongRTLChars(*paragraph)) {
-    paragraph->insert(0, 1, static_cast<char16>(base::i18n::kRightToLeftMark));
+    paragraph->insert(0, 1,
+                      static_cast<base::char16>(base::i18n::kRightToLeftMark));
   }
 #endif
 }
 
 #if defined(OS_WIN)
 std::string GetCanonicalLocale(const std::string& locale) {
   return base::i18n::GetCanonicalLocale(locale.c_str());
 }
 #endif
 
@@ skipping 220 matching lines @@
     return fallback_locale;
   }
 
   return std::string();
 
 #endif
 }
 
 bool IsLocaleNameTranslated(const char* locale,
                             const std::string& display_locale) {
-  string16 display_name =
+  base::string16 display_name =
       l10n_util::GetDisplayNameForLocale(locale, display_locale, false);
   // Because ICU sets the error code to U_USING_DEFAULT_WARNING whether or not
   // uloc_getDisplayName returns the actual translation or the default
   // value (locale code), we have to rely on this hack to tell whether
   // the translation is available or not.  If ICU doesn't have a translated
   // name for this locale, GetDisplayNameForLocale will just return the
   // locale code.
   return !IsStringASCII(display_name) || UTF16ToASCII(display_name) != locale;
 }
 
-string16 GetDisplayNameForLocale(const std::string& locale,
-                                 const std::string& display_locale,
-                                 bool is_for_ui) {
+base::string16 GetDisplayNameForLocale(const std::string& locale,
+                                       const std::string& display_locale,
+                                       bool is_for_ui) {
   std::string locale_code = locale;
   // Internally, we use the language code of zh-CN and zh-TW, but we want the
   // display names to be Chinese (Simplified) and Chinese (Traditional) instead
   // of Chinese (China) and Chinese (Taiwan).  To do that, we pass zh-Hans
   // and zh-Hant to ICU. Even with this mapping, we'd get
   // 'Chinese (Simplified Han)' and 'Chinese (Traditional Han)' in English and
   // even longer results in other languages. Arguably, they're better than
   // the current results : Chinese (China) / Chinese (Taiwan).
   // TODO(jungshik): Do one of the following:
   // 1. Special-case Chinese by getting the custom-translation for them
   // 2. Recycle IDS_ENCODING_{SIMP,TRAD}_CHINESE.
   // 3. Get translations for two directly from the ICU resouce bundle
   // because they're not accessible with other any API.
   // 4. Patch ICU to special-case zh-Hans/zh-Hant for us.
   // #1 and #2 wouldn't work if display_locale != current UI locale although
   // we can think of additional hack to work around the problem.
   // #3 can be potentially expensive.
   if (locale_code == "zh-CN")
     locale_code = "zh-Hans";
   else if (locale_code == "zh-TW")
     locale_code = "zh-Hant";
 
-  string16 display_name;
+  base::string16 display_name;
 #if defined(OS_ANDROID)
   // Use Java API to get locale display name so that we can remove most of
   // the lang data from icu data to reduce binary size, except for zh-Hans and
   // zh-Hant because the current Android Java API doesn't support scripts.
   // TODO(wangxianzhu): remove the special handling of zh-Hans and zh-Hant once
   // Android Java API supports scripts.
   if (!StartsWithASCII(locale_code, "zh-Han", true)) {
     display_name = GetDisplayNameForLocale(locale_code, display_locale);
   } else
 #endif
   {
     UErrorCode error = U_ZERO_ERROR;
     const int kBufferSize = 1024;
 
     int actual_size = uloc_getDisplayName(
         locale_code.c_str(), display_locale.c_str(),
         WriteInto(&display_name, kBufferSize), kBufferSize - 1, &error);
     DCHECK(U_SUCCESS(error));
     display_name.resize(actual_size);
   }
 
   // Add directional markup so parentheses are properly placed.
   if (is_for_ui && base::i18n::IsRTL())
     base::i18n::AdjustStringForLocaleDirection(&display_name);
   return display_name;
 }
 
-string16 GetDisplayNameForCountry(const std::string& country_code,
-                                  const std::string& display_locale) {
+base::string16 GetDisplayNameForCountry(const std::string& country_code,
+                                        const std::string& display_locale) {
   return GetDisplayNameForLocale("_" + country_code, display_locale, false);
 }
 
 std::string NormalizeLocale(const std::string& locale) {
   std::string normalized_locale(locale);
   std::replace(normalized_locale.begin(), normalized_locale.end(), '-', '_');
 
   return normalized_locale;
 }
 
@@ skipping 79 matching lines @@
     return false;
   }
 
   return true;
 }
 
 std::string GetStringUTF8(int message_id) {
   return UTF16ToUTF8(GetStringUTF16(message_id));
 }
 
-string16 GetStringUTF16(int message_id) {
+base::string16 GetStringUTF16(int message_id) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  string16 str = rb.GetLocalizedString(message_id);
+  base::string16 str = rb.GetLocalizedString(message_id);
   AdjustParagraphDirectionality(&str);
 
   return str;
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const std::vector<string16>& replacements,
-                         std::vector<size_t>* offsets) {
+base::string16 GetStringFUTF16(int message_id,
+                               const std::vector<base::string16>& replacements,
+                               std::vector<size_t>* offsets) {
   // TODO(tc): We could save a string copy if we got the raw string as
   // a StringPiece and were able to call ReplaceStringPlaceholders with
-  // a StringPiece format string and string16 substitution strings.  In
+  // a StringPiece format string and base::string16 substitution strings.  In
   // practice, the strings should be relatively short.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  const string16& format_string = rb.GetLocalizedString(message_id);
+  const base::string16& format_string = rb.GetLocalizedString(message_id);
 
 #ifndef NDEBUG
   // Make sure every replacement string is being used, so we don't just
   // silently fail to insert one. If |offsets| is non-NULL, then don't do this
   // check as the code may simply want to find the placeholders rather than
   // actually replacing them.
   if (!offsets) {
     std::string utf8_string = UTF16ToUTF8(format_string);
 
     // $9 is the highest allowed placeholder.
     for (size_t i = 0; i < 9; ++i) {
       bool placeholder_should_exist = replacements.size() > i;
 
       std::string placeholder =
           base::StringPrintf("$%d", static_cast<int>(i + 1));
       size_t pos = utf8_string.find(placeholder.c_str());
       if (placeholder_should_exist) {
         DCHECK_NE(std::string::npos, pos) <<
             " Didn't find a " << placeholder << " placeholder in " <<
             utf8_string;
       } else {
         DCHECK_EQ(std::string::npos, pos) <<
             " Unexpectedly found a " << placeholder << " placeholder in " <<
             utf8_string;
       }
     }
   }
 #endif
 
-  string16 formatted = ReplaceStringPlaceholders(format_string, replacements,
-                                                 offsets);
+  base::string16 formatted = ReplaceStringPlaceholders(
+      format_string, replacements, offsets);
   AdjustParagraphDirectionality(&formatted);
 
   return formatted;
 }
 
 std::string GetStringFUTF8(int message_id,
-                           const string16& a) {
+                           const base::string16& a) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a));
 }
 
 std::string GetStringFUTF8(int message_id,
-                           const string16& a,
-                           const string16& b) {
+                           const base::string16& a,
+                           const base::string16& b) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a, b));
 }
 
 std::string GetStringFUTF8(int message_id,
-                           const string16& a,
-                           const string16& b,
-                           const string16& c) {
+                           const base::string16& a,
+                           const base::string16& b,
+                           const base::string16& c) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a, b, c));
 }
 
 std::string GetStringFUTF8(int message_id,
-                           const string16& a,
-                           const string16& b,
-                           const string16& c,
-                           const string16& d) {
+                           const base::string16& a,
+                           const base::string16& b,
+                           const base::string16& c,
+                           const base::string16& d) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a, b, c, d));
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a) {
-  std::vector<string16> replacements;
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a) {
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
   return GetStringFUTF16(message_id, replacements, NULL);
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a,
-                         const string16& b) {
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               const base::string16& b) {
   return GetStringFUTF16(message_id, a, b, NULL);
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a,
-                         const string16& b,
-                         const string16& c) {
-  std::vector<string16> replacements;
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               const base::string16& b,
+                               const base::string16& c) {
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
   replacements.push_back(b);
   replacements.push_back(c);
   return GetStringFUTF16(message_id, replacements, NULL);
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a,
-                         const string16& b,
-                         const string16& c,
-                         const string16& d) {
-  std::vector<string16> replacements;
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               const base::string16& b,
+                               const base::string16& c,
+                               const base::string16& d) {
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
   replacements.push_back(b);
   replacements.push_back(c);
   replacements.push_back(d);
   return GetStringFUTF16(message_id, replacements, NULL);
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a,
-                         const string16& b,
-                         const string16& c,
-                         const string16& d,
-                         const string16& e) {
-  std::vector<string16> replacements;
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               const base::string16& b,
+                               const base::string16& c,
+                               const base::string16& d,
+                               const base::string16& e) {
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
   replacements.push_back(b);
   replacements.push_back(c);
   replacements.push_back(d);
   replacements.push_back(e);
   return GetStringFUTF16(message_id, replacements, NULL);
 }
 
-string16 GetStringFUTF16(int message_id, const string16& a, size_t* offset) {
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               size_t* offset) {
   DCHECK(offset);
   std::vector<size_t> offsets;
-  std::vector<string16> replacements;
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
-  string16 result = GetStringFUTF16(message_id, replacements, &offsets);
+  base::string16 result = GetStringFUTF16(message_id, replacements, &offsets);
   DCHECK(offsets.size() == 1);
   *offset = offsets[0];
   return result;
 }
 
-string16 GetStringFUTF16(int message_id,
-                         const string16& a,
-                         const string16& b,
-                         std::vector<size_t>* offsets) {
-  std::vector<string16> replacements;
+base::string16 GetStringFUTF16(int message_id,
+                               const base::string16& a,
+                               const base::string16& b,
+                               std::vector<size_t>* offsets) {
+  std::vector<base::string16> replacements;
   replacements.push_back(a);
   replacements.push_back(b);
   return GetStringFUTF16(message_id, replacements, offsets);
 }
 
-string16 GetStringFUTF16Int(int message_id, int a) {
+base::string16 GetStringFUTF16Int(int message_id, int a) {
   return GetStringFUTF16(message_id, UTF8ToUTF16(base::IntToString(a)));
 }
 
-string16 GetStringFUTF16Int(int message_id, int64 a) {
+base::string16 GetStringFUTF16Int(int message_id, int64 a) {
   return GetStringFUTF16(message_id, UTF8ToUTF16(base::Int64ToString(a)));
 }
 
-// Specialization of operator() method for string16 version.
+// Specialization of operator() method for base::string16 version.
 template <>
-bool StringComparator<string16>::operator()(const string16& lhs,
-                                            const string16& rhs) {
+bool StringComparator<base::string16>::operator()(const base::string16& lhs,
+                                                  const base::string16& rhs) {
   // If we can not get collator instance for specified locale, just do simple
   // string compare.
   if (!collator_)
     return lhs < rhs;
   return base::i18n::CompareString16WithCollator(collator_, lhs, rhs) ==
       UCOL_LESS;
 };
 
-string16 GetPluralStringFUTF16(const std::vector<int>& message_ids,
+base::string16 GetPluralStringFUTF16(const std::vector<int>& message_ids,
                                int number) {
   scoped_ptr<icu::PluralFormat> format = BuildPluralFormat(message_ids);
   DCHECK(format);
 
   UErrorCode err = U_ZERO_ERROR;
   icu::UnicodeString result_files_string = format->format(number, err);
   int capacity = result_files_string.length() + 1;
   DCHECK_GT(capacity, 1);
-  string16 result;
+  base::string16 result;
   result_files_string.extract(
       static_cast<UChar*>(WriteInto(&result, capacity)), capacity, err);
   DCHECK(U_SUCCESS(err));
   return result;
 }
 
 std::string GetPluralStringFUTF8(const std::vector<int>& message_ids,
                                  int number) {
   return base::UTF16ToUTF8(GetPluralStringFUTF16(message_ids, number));
 }
 
 void SortStrings16(const std::string& locale,
-                   std::vector<string16>* strings) {
+                   std::vector<base::string16>* strings) {
   SortVectorWithStringKey(locale, strings, false);
 }
 
 const std::vector<std::string>& GetAvailableLocales() {
   return g_available_locales.Get();
 }
 
 void GetAcceptLanguagesForLocale(const std::string& display_locale,
                                  std::vector<std::string>* locale_codes) {
   for (size_t i = 0; i < arraysize(kAcceptLanguageList); ++i) {
     if (!l10n_util::IsLocaleNameTranslated(kAcceptLanguageList[i],
                                            display_locale))
       // TODO(jungshik) : Put them at the of the list with language codes
       // enclosed by brackets instead of skipping.
         continue;
     locale_codes->push_back(kAcceptLanguageList[i]);
   }
 }
 
 int GetLocalizedContentsWidthInPixels(int pixel_resource_id) {
   int width = 0;
   base::StringToInt(l10n_util::GetStringUTF8(pixel_resource_id), &width);
   DCHECK_GT(width, 0);
   return width;
 }
 
 }  // namespace l10n_util