Remove wstring from l10n_util. Part 1....

app/l10n_util.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <glib/gutils.h>
 #endif
 
@@ skipping 550 matching lines @@
   }
   if (token_index == 0 && (token_len < 1 || token_len > 3)) {
     return false;
   } else if (token_len < 1 || token_len > 8) {
     return false;
   }
 
   return true;
 }
 
+#if CRBUG_9911_OBSOLETE_GOING_AWAY
 std::wstring GetString(int message_id) {
   return UTF16ToWide(GetStringUTF16(message_id));
 }
+#endif
 
 std::string GetStringUTF8(int message_id) {
   return UTF16ToUTF8(GetStringUTF16(message_id));
 }
 
 string16 GetStringUTF16(int message_id) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   string16 str = rb.GetLocalizedString(message_id);
   AdjustParagraphDirectionality(&str);
 
@@ skipping 37 matching lines @@
   }
 #endif
 
   string16 formatted = ReplaceStringPlaceholders(format_string, replacements,
                                                  offsets);
   AdjustParagraphDirectionality(&formatted);
 
   return formatted;
 }
 
+#if CRBUG_9911_OBSOLETE_GOING_AWAY
 #if !defined(WCHAR_T_IS_UTF16)
 std::wstring GetStringF(int message_id, const std::wstring& a) {
   return UTF16ToWide(GetStringFUTF16(message_id, WideToUTF16(a)));
 }
 
 std::wstring GetStringF(int message_id,
                         const std::wstring& a,
                         const std::wstring& b) {
   return UTF16ToWide(GetStringFUTF16(message_id, WideToUTF16(a),
                                      WideToUTF16(b)));
 }
 
 std::wstring GetStringF(int message_id,
                         const std::wstring& a,
                         const std::wstring& b,
                         const std::wstring& c) {
   return UTF16ToWide(GetStringFUTF16(message_id, WideToUTF16(a),
                                      WideToUTF16(b), WideToUTF16(c)));
 }
 
 std::wstring GetStringF(int message_id,
                         const std::wstring& a,
                         const std::wstring& b,
                         const std::wstring& c,
                         const std::wstring& d) {
   return UTF16ToWide(GetStringFUTF16(message_id, WideToUTF16(a), WideToUTF16(b),
                                      WideToUTF16(c), WideToUTF16(d)));
 }
 #endif
+#endif
 
 std::string GetStringFUTF8(int message_id,
                            const string16& a) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a));
 }
 
 std::string GetStringFUTF8(int message_id,
                            const string16& a,
                            const string16& b) {
   return UTF16ToUTF8(GetStringFUTF16(message_id, a, b));
@@ skipping 44 matching lines @@
                          const string16& c,
                          const string16& d) {
   std::vector<string16> replacements;
   replacements.push_back(a);
   replacements.push_back(b);
   replacements.push_back(c);
   replacements.push_back(d);
   return GetStringF(message_id, replacements, NULL);
 }
 
+#if CRBUG_9911_OBSOLETE_GOING_AWAY
 std::wstring GetStringF(int message_id, const std::wstring& a, size_t* offset) {
   DCHECK(offset);
   std::vector<size_t> offsets;
   std::vector<string16> replacements;
   replacements.push_back(WideToUTF16(a));
   string16 result = GetStringF(message_id, replacements, &offsets);
   DCHECK(offsets.size() == 1);
   *offset = offsets[0];
   return UTF16ToWide(result);
 }
 
 std::wstring GetStringF(int message_id,
                         const std::wstring& a,
                         const std::wstring& b,
                         std::vector<size_t>* offsets) {
   std::vector<string16> replacements;
   replacements.push_back(WideToUTF16(a));
   replacements.push_back(WideToUTF16(b));
   return UTF16ToWide(GetStringF(message_id, replacements, offsets));
 }
+#endif
 
 string16 GetStringFUTF16(int message_id, const string16& a, size_t* offset) {
   DCHECK(offset);
   std::vector<size_t> offsets;
   std::vector<string16> replacements;
   replacements.push_back(a);
   string16 result = GetStringF(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;
   replacements.push_back(a);
   replacements.push_back(b);
   return GetStringF(message_id, replacements, offsets);
 }
 
+#if CRBUG_9911_OBSOLETE_GOING_AWAY
 std::wstring GetStringF(int message_id, int a) {
   return GetStringF(message_id, UTF8ToWide(base::IntToString(a)));
 }
 
 std::wstring GetStringF(int message_id, int64 a) {
   return GetStringF(message_id, UTF8ToWide(base::Int64ToString(a)));
 }
+#endif
+
+string16 GetStringFUTF16(int message_id, int a) {
+  return GetStringFUTF16(message_id, UTF8ToUTF16(base::IntToString(a)));
+}
+
+string16 GetStringFUTF16(int message_id, int64 a) {
+  return GetStringFUTF16(message_id, UTF8ToUTF16(base::Int64ToString(a)));
+}
 
 string16 TruncateString(const string16& string, size_t length) {
   if (string.size() <= length)
     // String fits, return it.
     return string;
 
   if (length == 0) {
     // No room for the elide string, return an empty string.
     return string16();
   }
@@ skipping 97 matching lines @@
   string16 lhs_utf16 = WideToUTF16(lhs);
   string16 rhs_utf16 = WideToUTF16(rhs);
 
   result = CompareString16WithCollator(collator, lhs_utf16, rhs_utf16);
 #else
   result = CompareString16WithCollator(collator, lhs, rhs);
 #endif
   return result;
 }
 
-// Specialization of operator() method for std::wstring version.
-template <>
-bool StringComparator<std::wstring>::operator()(const std::wstring& lhs,
-                                                const std::wstring& rhs) {
-  // If we can not get collator instance for specified locale, just do simple
-  // string compare.
-  if (!collator_)
-    return lhs < rhs;
-  return CompareStringWithCollator(collator_, lhs, rhs) == UCOL_LESS;
-};
-
-#if !defined(WCHAR_T_IS_UTF16)
 // Specialization of operator() method for string16 version.
 template <>
 bool StringComparator<string16>::operator()(const string16& lhs,
                                             const string16& rhs) {
   // If we can not get collator instance for specified locale, just do simple
   // string compare.
   if (!collator_)
     return lhs < rhs;
   return CompareString16WithCollator(collator_, lhs, rhs) == UCOL_LESS;
 };
-#endif  // !defined(WCHAR_T_IS_UTF16)
-
-void SortStrings(const std::string& locale,
-                 std::vector<std::wstring>* strings) {
-  SortVectorWithStringKey(locale, strings, false);
-}
 
 void SortStrings16(const std::string& locale,
                    std::vector<string16>* strings) {
   SortVectorWithStringKey(locale, strings, false);
 }
 
 const std::vector<std::string>& GetAvailableLocales() {
   static std::vector<std::string> locales;
   if (locales.empty()) {
     int num_locales = uloc_countAvailable();
@@ skipping 32 matching lines @@
   for (size_t i = 0; i < arraysize(kAcceptLanguageList); ++i) {
     if (!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]);
   }
 }
 
 }  // namespace l10n_util