Convert std::wstring encoding names to std::string in a bunch of files.

chrome/browser/character_encoding.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/character_encoding.h"
 
 #include <map>
 #include <set>
 
 #include "app/l10n_util.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "grit/generated_resources.h"
 #include "unicode/ucnv.h"
 
 namespace {
 
 // The maximum length of short list of recently user selected encodings is 3.
 const size_t kUserSelectedEncodingsMaxLength = 3;
 
 typedef struct {
   int resource_id;
-  const wchar_t* name;
+  const char* name;
   int category_string_id;
 } CanonicalEncodingData;
 
 // An array of all supported canonical encoding names.
 static CanonicalEncodingData canonical_encoding_names[] = {
-  { IDC_ENCODING_UTF8, L"UTF-8", IDS_ENCODING_UNICODE },
-  { IDC_ENCODING_UTF16LE, L"UTF-16LE", IDS_ENCODING_UNICODE },
-  { IDC_ENCODING_ISO88591, L"ISO-8859-1", IDS_ENCODING_WESTERN },
-  { IDC_ENCODING_WINDOWS1252, L"windows-1252", IDS_ENCODING_WESTERN },
-  { IDC_ENCODING_GBK, L"GBK", IDS_ENCODING_SIMP_CHINESE },
-  { IDC_ENCODING_GB18030, L"gb18030", IDS_ENCODING_SIMP_CHINESE },
-  { IDC_ENCODING_BIG5, L"Big5", IDS_ENCODING_TRAD_CHINESE },
-  { IDC_ENCODING_BIG5HKSCS, L"Big5-HKSCS", IDS_ENCODING_TRAD_CHINESE },
-  { IDC_ENCODING_KOREAN, L"windows-949", IDS_ENCODING_KOREAN },
-  { IDC_ENCODING_SHIFTJIS, L"Shift_JIS", IDS_ENCODING_JAPANESE },
-  { IDC_ENCODING_EUCJP, L"EUC-JP", IDS_ENCODING_JAPANESE },
-  { IDC_ENCODING_ISO2022JP, L"ISO-2022-JP", IDS_ENCODING_JAPANESE },
-  { IDC_ENCODING_THAI, L"windows-874", IDS_ENCODING_THAI },
-  { IDC_ENCODING_ISO885915, L"ISO-8859-15", IDS_ENCODING_WESTERN },
-  { IDC_ENCODING_MACINTOSH, L"macintosh", IDS_ENCODING_WESTERN },
-  { IDC_ENCODING_ISO88592, L"ISO-8859-2", IDS_ENCODING_CENTRAL_EUROPEAN },
-  { IDC_ENCODING_WINDOWS1250, L"windows-1250", IDS_ENCODING_CENTRAL_EUROPEAN },
-  { IDC_ENCODING_ISO88595, L"ISO-8859-5", IDS_ENCODING_CYRILLIC },
-  { IDC_ENCODING_WINDOWS1251, L"windows-1251", IDS_ENCODING_CYRILLIC },
-  { IDC_ENCODING_KOI8R, L"KOI8-R", IDS_ENCODING_CYRILLIC },
-  { IDC_ENCODING_KOI8U, L"KOI8-U", IDS_ENCODING_CYRILLIC },
-  { IDC_ENCODING_ISO88597, L"ISO-8859-7", IDS_ENCODING_GREEK },
-  { IDC_ENCODING_WINDOWS1253, L"windows-1253", IDS_ENCODING_GREEK },
-  { IDC_ENCODING_WINDOWS1254, L"windows-1254", IDS_ENCODING_TURKISH },
-  { IDC_ENCODING_WINDOWS1256, L"windows-1256", IDS_ENCODING_ARABIC },
-  { IDC_ENCODING_ISO88596, L"ISO-8859-6", IDS_ENCODING_ARABIC },
-  { IDC_ENCODING_WINDOWS1255, L"windows-1255", IDS_ENCODING_HEBREW },
-  { IDC_ENCODING_ISO88598I, L"ISO-8859-8-I", IDS_ENCODING_HEBREW },
-  { IDC_ENCODING_ISO88598, L"ISO-8859-8", IDS_ENCODING_HEBREW },
-  { IDC_ENCODING_WINDOWS1258, L"windows-1258", IDS_ENCODING_VIETNAMESE },
-  { IDC_ENCODING_ISO88594, L"ISO-8859-4", IDS_ENCODING_BALTIC },
-  { IDC_ENCODING_ISO885913, L"ISO-8859-13", IDS_ENCODING_BALTIC },
-  { IDC_ENCODING_WINDOWS1257, L"windows-1257", IDS_ENCODING_BALTIC },
-  { IDC_ENCODING_ISO88593, L"ISO-8859-3", IDS_ENCODING_SOUTH_EUROPEAN },
-  { IDC_ENCODING_ISO885910, L"ISO-8859-10", IDS_ENCODING_NORDIC },
-  { IDC_ENCODING_ISO885914, L"ISO-8859-14", IDS_ENCODING_CELTIC },
-  { IDC_ENCODING_ISO885916, L"ISO-8859-16", IDS_ENCODING_ROMANIAN },
+  { IDC_ENCODING_UTF8, "UTF-8", IDS_ENCODING_UNICODE },
+  { IDC_ENCODING_UTF16LE, "UTF-16LE", IDS_ENCODING_UNICODE },
+  { IDC_ENCODING_ISO88591, "ISO-8859-1", IDS_ENCODING_WESTERN },
+  { IDC_ENCODING_WINDOWS1252, "windows-1252", IDS_ENCODING_WESTERN },
+  { IDC_ENCODING_GBK, "GBK", IDS_ENCODING_SIMP_CHINESE },
+  { IDC_ENCODING_GB18030, "gb18030", IDS_ENCODING_SIMP_CHINESE },
+  { IDC_ENCODING_BIG5, "Big5", IDS_ENCODING_TRAD_CHINESE },
+  { IDC_ENCODING_BIG5HKSCS, "Big5-HKSCS", IDS_ENCODING_TRAD_CHINESE },
+  { IDC_ENCODING_KOREAN, "windows-949", IDS_ENCODING_KOREAN },
+  { IDC_ENCODING_SHIFTJIS, "Shift_JIS", IDS_ENCODING_JAPANESE },
+  { IDC_ENCODING_EUCJP, "EUC-JP", IDS_ENCODING_JAPANESE },
+  { IDC_ENCODING_ISO2022JP, "ISO-2022-JP", IDS_ENCODING_JAPANESE },
+  { IDC_ENCODING_THAI, "windows-874", IDS_ENCODING_THAI },
+  { IDC_ENCODING_ISO885915, "ISO-8859-15", IDS_ENCODING_WESTERN },
+  { IDC_ENCODING_MACINTOSH, "macintosh", IDS_ENCODING_WESTERN },
+  { IDC_ENCODING_ISO88592, "ISO-8859-2", IDS_ENCODING_CENTRAL_EUROPEAN },
+  { IDC_ENCODING_WINDOWS1250, "windows-1250", IDS_ENCODING_CENTRAL_EUROPEAN },
+  { IDC_ENCODING_ISO88595, "ISO-8859-5", IDS_ENCODING_CYRILLIC },
+  { IDC_ENCODING_WINDOWS1251, "windows-1251", IDS_ENCODING_CYRILLIC },
+  { IDC_ENCODING_KOI8R, "KOI8-R", IDS_ENCODING_CYRILLIC },
+  { IDC_ENCODING_KOI8U, "KOI8-U", IDS_ENCODING_CYRILLIC },
+  { IDC_ENCODING_ISO88597, "ISO-8859-7", IDS_ENCODING_GREEK },
+  { IDC_ENCODING_WINDOWS1253, "windows-1253", IDS_ENCODING_GREEK },
+  { IDC_ENCODING_WINDOWS1254, "windows-1254", IDS_ENCODING_TURKISH },
+  { IDC_ENCODING_WINDOWS1256, "windows-1256", IDS_ENCODING_ARABIC },
+  { IDC_ENCODING_ISO88596, "ISO-8859-6", IDS_ENCODING_ARABIC },
+  { IDC_ENCODING_WINDOWS1255, "windows-1255", IDS_ENCODING_HEBREW },
+  { IDC_ENCODING_ISO88598I, "ISO-8859-8-I", IDS_ENCODING_HEBREW },
+  { IDC_ENCODING_ISO88598, "ISO-8859-8", IDS_ENCODING_HEBREW },
+  { IDC_ENCODING_WINDOWS1258, "windows-1258", IDS_ENCODING_VIETNAMESE },
+  { IDC_ENCODING_ISO88594, "ISO-8859-4", IDS_ENCODING_BALTIC },
+  { IDC_ENCODING_ISO885913, "ISO-8859-13", IDS_ENCODING_BALTIC },
+  { IDC_ENCODING_WINDOWS1257, "windows-1257", IDS_ENCODING_BALTIC },
+  { IDC_ENCODING_ISO88593, "ISO-8859-3", IDS_ENCODING_SOUTH_EUROPEAN },
+  { IDC_ENCODING_ISO885910, "ISO-8859-10", IDS_ENCODING_NORDIC },
+  { IDC_ENCODING_ISO885914, "ISO-8859-14", IDS_ENCODING_CELTIC },
+  { IDC_ENCODING_ISO885916, "ISO-8859-16", IDS_ENCODING_ROMANIAN },
 };
 
 static const int canonical_encoding_names_length =
     arraysize(canonical_encoding_names);
 
-typedef std::map<int, std::pair<const wchar_t*, int> >
+typedef std::map<int, std::pair<const char*, int> >
     IdToCanonicalEncodingNameMapType;
-typedef std::map<const std::wstring, int> CanonicalEncodingNameToIdMapType;
+typedef std::map<const std::string, int> CanonicalEncodingNameToIdMapType;
 
 class CanonicalEncodingMap {
  public:
   CanonicalEncodingMap()
       : id_to_encoding_name_map_(NULL),
         encoding_name_to_id_map_(NULL) { }
   const IdToCanonicalEncodingNameMapType* GetIdToCanonicalEncodingNameMapData();
   const CanonicalEncodingNameToIdMapType* GetCanonicalEncodingNameToIdMapData();
   std::vector<int>* const locale_dependent_encoding_ids() {
     return &locale_dependent_encoding_ids_;
   }
 
   std::vector<CharacterEncoding::EncodingInfo>* const
       current_display_encodings() {
     return &current_display_encodings_;
   }
 
  private:
   scoped_ptr<IdToCanonicalEncodingNameMapType> id_to_encoding_name_map_;
   scoped_ptr<CanonicalEncodingNameToIdMapType> encoding_name_to_id_map_;
   std::vector<int> locale_dependent_encoding_ids_;
   std::vector<CharacterEncoding::EncodingInfo> current_display_encodings_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(CanonicalEncodingMap);
+  DISALLOW_COPY_AND_ASSIGN(CanonicalEncodingMap);
 };
 
 const IdToCanonicalEncodingNameMapType*
     CanonicalEncodingMap::GetIdToCanonicalEncodingNameMapData() {
   // Testing and building map is not thread safe, this function is supposed to
   // only run in UI thread. Myabe I should add a lock in here for making it as
   // thread safe.
   if (!id_to_encoding_name_map_.get()) {
     id_to_encoding_name_map_.reset(new IdToCanonicalEncodingNameMapType);
     for (int i = 0; i < canonical_encoding_names_length; ++i) {
@@ skipping 61 matching lines @@
   IDC_ENCODING_ISO885916,
 };
 
 const int default_encoding_menus_length = arraysize(default_encoding_menus);
 
 // Parse the input |encoding_list| which is a encoding list separated with
 // comma, get available encoding ids and save them to |available_list|.
 // The parameter |maximum_size| indicates maximum size of encoding items we
 // want to get from the |encoding_list|.
 void ParseEncodingListSeparatedWithComma(
-    const std::wstring& encoding_list, std::vector<int>* const available_list,
+    const std::string& encoding_list, std::vector<int>* const available_list,
     size_t maximum_size) {
-  WStringTokenizer tokenizer(encoding_list, L",");
+  StringTokenizer tokenizer(encoding_list, ",");
   while (tokenizer.GetNext()) {
     int id = CharacterEncoding::GetCommandIdByCanonicalEncodingName(
         tokenizer.token());
     // Ignore invalid encoding.
     if (!id)
       continue;
     available_list->push_back(id);
     if (available_list->size() == maximum_size)
       return;
   }
 }
 
-std::wstring GetEncodingDisplayName(std::wstring encoding_name,
-                                    int category_string_id) {
-  std::wstring category_name = l10n_util::GetString(category_string_id);
+string16 GetEncodingDisplayName(std::string encoding_name,
+                                int category_string_id) {
+  string16 category_name = l10n_util::GetStringUTF16(category_string_id);
   if (category_string_id != IDS_ENCODING_KOREAN &&
       category_string_id != IDS_ENCODING_THAI &&
       category_string_id != IDS_ENCODING_TURKISH) {
-    return l10n_util::GetStringF(IDS_ENCODING_DISPLAY_TEMPLATE,
-                                 category_name,
-                                 encoding_name);
+    return l10n_util::GetStringFUTF16(IDS_ENCODING_DISPLAY_TEMPLATE,
+                                      category_name,
+                                      ASCIIToUTF16(encoding_name));
   }
   return category_name;
 }
 
 int GetEncodingCategoryStringIdByCommandId(int id) {
   const IdToCanonicalEncodingNameMapType* map =
       canonical_encoding_name_map_singleton.
           GetIdToCanonicalEncodingNameMapData();
   DCHECK(map);
 
   IdToCanonicalEncodingNameMapType::const_iterator found_name = map->find(id);
   if (found_name != map->end())
     return found_name->second.second;
   return 0;
 }
 
-std::wstring GetEncodingCategoryStringByCommandId(int id) {
+std::string GetEncodingCategoryStringByCommandId(int id) {
   int category_id = GetEncodingCategoryStringIdByCommandId(id);
   if (category_id)
-    return l10n_util::GetString(category_id);
-  return std::wstring();
+    return l10n_util::GetStringUTF8(category_id);
+  return std::string();
 }
 
 }  // namespace
 
 CharacterEncoding::EncodingInfo::EncodingInfo(int id)
     : encoding_id(id) {
-  encoding_category_name = GetEncodingCategoryStringByCommandId(id),
-  encoding_display_name = GetCanonicalEncodingDisplayNameByCommandId(id);
+  encoding_category_name = UTF8ToWide(GetEncodingCategoryStringByCommandId(id));
+  encoding_display_name = UTF16ToWideHack(
+      GetCanonicalEncodingDisplayNameByCommandId(id));
 }
 
 // Static.
 int CharacterEncoding::GetCommandIdByCanonicalEncodingName(
-    const std::wstring& encoding_name) {
+    const std::string& encoding_name) {
   const CanonicalEncodingNameToIdMapType* map =
       canonical_encoding_name_map_singleton.
           GetCanonicalEncodingNameToIdMapData();
   DCHECK(map);
 
   CanonicalEncodingNameToIdMapType::const_iterator found_id =
       map->find(encoding_name);
   if (found_id != map->end())
     return found_id->second;
   return 0;
 }
 
 // Static.
-std::wstring CharacterEncoding::GetCanonicalEncodingNameByCommandId(int id) {
+std::string CharacterEncoding::GetCanonicalEncodingNameByCommandId(int id) {
   const IdToCanonicalEncodingNameMapType* map =
       canonical_encoding_name_map_singleton.
           GetIdToCanonicalEncodingNameMapData();
   DCHECK(map);
 
   IdToCanonicalEncodingNameMapType::const_iterator found_name = map->find(id);
   if (found_name != map->end())
     return found_name->second.first;
-  return std::wstring();
+  return std::string();
 }
 
 // Static.
-std::wstring CharacterEncoding::GetCanonicalEncodingDisplayNameByCommandId(
+string16 CharacterEncoding::GetCanonicalEncodingDisplayNameByCommandId(
     int id) {
   const IdToCanonicalEncodingNameMapType* map =
       canonical_encoding_name_map_singleton.
           GetIdToCanonicalEncodingNameMapData();
   DCHECK(map);
 
   IdToCanonicalEncodingNameMapType::const_iterator found_name = map->find(id);
   if (found_name != map->end())
     return GetEncodingDisplayName(found_name->second.first,
                                   found_name->second.second);
-  return std::wstring();
+  return string16();
 }
 
 // Static.
 // Return count number of all supported canonical encoding.
 int CharacterEncoding::GetSupportCanonicalEncodingCount() {
   return canonical_encoding_names_length;
 }
 
 // Static.
-std::wstring CharacterEncoding::GetCanonicalEncodingNameByIndex(int index) {
+std::string CharacterEncoding::GetCanonicalEncodingNameByIndex(int index) {
   if (index < canonical_encoding_names_length)
     return canonical_encoding_names[index].name;
-  return std::wstring();
+  return std::string();
 }
 
 // Static.
-std::wstring CharacterEncoding::GetCanonicalEncodingDisplayNameByIndex(
+string16 CharacterEncoding::GetCanonicalEncodingDisplayNameByIndex(
     int index) {
   if (index < canonical_encoding_names_length)
     return GetEncodingDisplayName(canonical_encoding_names[index].name,
         canonical_encoding_names[index].category_string_id);
-  return std::wstring();
+  return string16();
 }
 
 // Static.
 int CharacterEncoding::GetEncodingCommandIdByIndex(int index) {
   if (index < canonical_encoding_names_length)
     return canonical_encoding_names[index].resource_id;
   return 0;
 }
 
 // Static.
-std::wstring CharacterEncoding::GetCanonicalEncodingNameByAliasName(
-    const std::wstring& alias_name) {
+std::string CharacterEncoding::GetCanonicalEncodingNameByAliasName(
+    const std::string& alias_name) {
   // If the input alias_name is already canonical encoding name, just return it.
   const CanonicalEncodingNameToIdMapType* map =
       canonical_encoding_name_map_singleton.
           GetCanonicalEncodingNameToIdMapData();
   DCHECK(map);
 
   CanonicalEncodingNameToIdMapType::const_iterator found_id =
       map->find(alias_name);
   if (found_id != map->end())
     return alias_name;
 
   UErrorCode error_code = U_ZERO_ERROR;
 
   const char* canonical_name = ucnv_getCanonicalName(
-      WideToASCII(alias_name).c_str(), "MIME", &error_code);
+      alias_name.c_str(), "MIME", &error_code);
   // If failed,  then try IANA next.
   if (U_FAILURE(error_code) || !canonical_name) {
     error_code = U_ZERO_ERROR;
     canonical_name = ucnv_getCanonicalName(
-      WideToASCII(alias_name).c_str(), "IANA", &error_code);
+      alias_name.c_str(), "IANA", &error_code);
   }
 
   if (canonical_name) {
     // TODO(jnd) use a map to handle all customized {alias, canonical}
     // encoding mappings if we have more than one pair.
     // We don't want to add an unnecessary charset to the encoding menu, so we
     // alias 'US-ASCII' to 'ISO-8859-1' in our UI without touching WebKit.
     // http://crbug.com/15801.
-    if (alias_name == L"US-ASCII")
+    if (alias_name == "US-ASCII")
       return GetCanonicalEncodingNameByCommandId(IDC_ENCODING_ISO88591);
-    return ASCIIToWide(canonical_name);
+    return canonical_name;
   } else {
-    return std::wstring();
+    return std::string();
   }
 }
 
 // Static
 // According to the behavior of user recently selected encoding short list in
 // FireFox, we always put UTF-8 as toppest position, after then put user
 // recently selected encodings, then put local dependent encoding items.
 // At last, we put all rest encoding items.
 const std::vector<CharacterEncoding::EncodingInfo>*
     CharacterEncoding::GetCurrentDisplayEncodings(
     const std::string& locale,
-    const std::wstring& locale_encodings,
-    const std::wstring& recently_select_encodings) {
+    const std::string& locale_encodings,
+    const std::string& recently_select_encodings) {
   std::vector<int>* const locale_dependent_encoding_list =
       canonical_encoding_name_map_singleton.locale_dependent_encoding_ids();
   std::vector<CharacterEncoding::EncodingInfo>* const encoding_list =
       canonical_encoding_name_map_singleton.current_display_encodings();
 
   // Initialize locale dependent static encoding list.
   if (locale_dependent_encoding_list->empty() && !locale_encodings.empty())
     ParseEncodingListSeparatedWithComma(locale_encodings,
                                         locale_dependent_encoding_list,
                                         kUserSelectedEncodingsMaxLength);
 
-  static std::wstring cached_user_selected_encodings;
+  static std::string cached_user_selected_encodings;
   // Build current display encoding list.
   if (encoding_list->empty() ||
       cached_user_selected_encodings != recently_select_encodings) {
     // Update user recently selected encodings.
     cached_user_selected_encodings = recently_select_encodings;
     // Clear old encoding list since user recently selected encodings changed.
     encoding_list->clear();
     // Always add UTF-8 to first encoding position.
     encoding_list->push_back(EncodingInfo(IDC_ENCODING_UTF8));
     std::set<int> inserted_encoding;
@@ skipping 52 matching lines @@
                                        start_sorted_index,
                                        encoding_list->size(),
                                        true);
   }
   DCHECK(!encoding_list->empty());
   return encoding_list;
 }
 
 // Static
 bool CharacterEncoding::UpdateRecentlySelectdEncoding(
-    const std::wstring& original_selected_encodings,
+    const std::string& original_selected_encodings,
     int new_selected_encoding_id,
-    std::wstring* selected_encodings) {
+    std::string* selected_encodings) {
   // Get encoding name.
-  std::wstring encoding_name =
+  std::string encoding_name =
       GetCanonicalEncodingNameByCommandId(new_selected_encoding_id);
   DCHECK(!encoding_name.empty());
   // Check whether the new encoding is in local dependent encodings or original
   // recently selected encodings. If yes, do not add it.
   std::vector<int>* locale_dependent_encoding_list =
       canonical_encoding_name_map_singleton.locale_dependent_encoding_ids();
   DCHECK(locale_dependent_encoding_list);
   std::vector<int> selected_encoding_list;
   ParseEncodingListSeparatedWithComma(original_selected_encodings,
                                       &selected_encoding_list,
@@ skipping 17 matching lines @@
   // Insert new encoding to head of selected encoding list.
   *selected_encodings = encoding_name;
   // Generate the string for rest selected encoding list.
   for (std::vector<int>::const_iterator it = selected_encoding_list.begin();
        it != selected_encoding_list.end(); ++it) {
     selected_encodings->append(1, L',');
     selected_encodings->append(GetCanonicalEncodingNameByCommandId(*it));
   }
   return true;
 }