Add NormalizeLanguageCode() to normalize language codes.

chrome/browser/chromeos/options/language_config_view.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 "chrome/browser/chromeos/options/language_config_view.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/language_library.h"
 #include "chrome/browser/chromeos/options/language_hangul_config_view.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/browser/language_combobox_model.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "gfx/font.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
+#include "third_party/icu/public/common/unicode/uloc.h"
 #include "views/controls/button/checkbox.h"
 #include "views/controls/combobox/combobox.h"
 #include "views/controls/label.h"
 #include "views/fill_layout.h"
 #include "views/grid_layout.h"
 #include "views/standard_layout.h"
 #include "views/window/window.h"
 
 namespace chromeos {
 using views::ColumnSet;
@@ skipping 100 matching lines @@
     language_combobox_ = new views::Combobox(language_combobox_model_.get());
     language_combobox_->SetSelectedItem(selected_index_);
     language_combobox_->set_listener(this);
     layout->StartRow(0, kColumnSetId);
     layout->AddView(language_combobox_);
   }
 
   // Creates the language combobox model from the supported languages.
   LanguageComboboxModel* CreateLanguageComboboxModel() {
     std::vector<std::string> language_codes;
-    parent_view_->GetSupportedLangageCodes(&language_codes);
+    parent_view_->GetSupportedLanguageCodes(&language_codes);
     // LanguageComboboxModel sorts languages by their display names.
     return new LanguageComboboxModelWithOthers(NULL, language_codes);
   }
 
   LanguageConfigView* parent_view_;
 
   // Combobox and its corresponding model.
   scoped_ptr<LanguageComboboxModel> language_combobox_model_;
   views::Combobox* language_combobox_;
   views::View* contents_;
@@ skipping 145 matching lines @@
   // Add the title label.
   layout->StartRow(0, kTitleColumnSetId);
   layout->AddView(title_label);
   layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
   // Add input method names and configuration buttons.
   input_method_buttons_.clear();
   input_method_checkboxes_.clear();
 
   std::vector<std::string> language_ids;
-  GetSupportedLangageIDs(&language_ids);
+  GetSupportedLanguageIDs(&language_ids);
   for (size_t i = 0; i < language_ids.size(); ++i) {
     const std::string& language_id = language_ids[i];
     const std::string language_code = GetLanguageCodeFromID(language_id);
     const std::string display_name = GetDisplayNameFromID(language_id);
     if (language_code == target_language_code) {
       layout->StartRow(0, kDoubleColumnSetId);
       InputMethodCheckbox* checkbox
           = new InputMethodCheckbox(language_id, display_name);
       checkbox->set_listener(this);
       checkbox->SetChecked(LanguageIsActivated(language_id));
@@ skipping 113 matching lines @@
   input_method_config_view_map_["hangul"] =
       CreateLanguageHangulConfigView;
 }
 
 void LanguageConfigView::InitLanguageIdMaps() {
   // GetSupportedLanguages() never return NULL.
   scoped_ptr<InputLanguageList> supported_language_list(
       CrosLibrary::Get()->GetLanguageLibrary()->GetSupportedLanguages());
   for (size_t i = 0; i < supported_language_list->size(); ++i) {
     const InputLanguage& language = supported_language_list->at(i);
+    // Normalize the language code as some engines return three-letter
+    // codes like "jpn" wheres some other engines return two-letter codes
+    // like "ja".
+    std::string language_code = NormalizeLanguageCode(language.language_code);
     id_to_language_code_map_.insert(
-        std::make_pair(language.id, language.language_code));
+        std::make_pair(language.id, language_code));
     id_to_display_name_map_.insert(
         std::make_pair(language.id, language.display_name));
   }
 }
 
 views::View* LanguageConfigView::CreateContentsOnLeft() {
   views::View* contents = new views::View;
   GridLayout* layout = new GridLayout(contents);
   contents->SetLayoutManager(layout);
 
@@ skipping 48 matching lines @@
 }
 
 void LanguageConfigView::OnAddLanguage(const std::string& language_code) {
   if (std::find(preferred_language_codes_.begin(),
                 preferred_language_codes_.end(),
                 language_code) == preferred_language_codes_.end()) {
     // Activate the first input language associated with the language. We have
     // to call this before the OnItemsAdded() call below so the checkbox for
     // the first input language gets checked.
     std::vector<std::string> language_ids;
-    GetSupportedLangageIDs(&language_ids);
+    GetSupportedLanguageIDs(&language_ids);
     for (size_t i = 0; i < language_ids.size(); ++i) {
       if (GetLanguageCodeFromID(language_ids[i]) == language_code) {
         SetLanguageActivated(language_ids[i], true);
         break;
       }
     }
 
     // Append the language to the list of language codes.
     preferred_language_codes_.push_back(language_code);
     // Update the language table accordingly.
     preferred_language_table_->OnItemsAdded(RowCount() - 1, 1);
     preferred_language_table_->SelectRow(RowCount() - 1);
   }
 }
 
 void LanguageConfigView::DeactivateInputLanguagesFor(
     const std::string& language_code) {
   std::vector<std::string> language_ids;
-  GetSupportedLangageIDs(&language_ids);
+  GetSupportedLanguageIDs(&language_ids);
   for (size_t i = 0; i < language_ids.size(); ++i) {
     if (GetLanguageCodeFromID(language_ids[i]) == language_code) {
       SetLanguageActivated(language_ids[i], false);
       // Do not break; here in order to disable all engines that belong to
       // |language_code|.
     }
   }
 
   // Switch back to the US English.
   // TODO(yusukes): what if "USA" is not active?
@@ skipping 46 matching lines @@
           language_ids.end());
 }
 
 void LanguageConfigView::GetActiveLanguageIDs(
     std::vector<std::string>* out_language_ids) {
   const std::wstring value = preload_engines_.GetValue();
   out_language_ids->clear();
   SplitString(WideToUTF8(value), ',', out_language_ids);
 }
 
-void LanguageConfigView::GetSupportedLangageIDs(
+void LanguageConfigView::GetSupportedLanguageIDs(
     std::vector<std::string>* out_language_ids) const {
   out_language_ids->clear();
   std::map<std::string, std::string>::const_iterator iter;
   for (iter = id_to_language_code_map_.begin();
        iter != id_to_language_code_map_.end();
        ++iter) {
     out_language_ids->push_back(iter->first);
   }
 }
 
-void LanguageConfigView::GetSupportedLangageCodes(
+void LanguageConfigView::GetSupportedLanguageCodes(
     std::vector<std::string>* out_language_codes) const {
   std::set<std::string> language_code_set;
   std::map<std::string, std::string>::const_iterator iter;
   for (iter = id_to_language_code_map_.begin();
        iter != id_to_language_code_map_.end();
        ++iter) {
     language_code_set.insert(iter->second);
   }
   out_language_codes->clear();
   out_language_codes->assign(
@@ skipping 33 matching lines @@
     const std::wstring& language_name) {
   // "t" is used as the language code for input methods that don't fall
   // under any other languages.
   if (language_name == L"t") {
     return l10n_util::GetString(
         IDS_OPTIONS_SETTINGS_LANGUAGES_OTHERS);
   }
   return language_name;
 }
 
+std::string LanguageConfigView::NormalizeLanguageCode(
+    const std::string& language_code) {
+  // We only handle two-letter codes here.
+  // Some ibus engines return locale codes like "zh_CN" as language codes,
+  // and we don't want to rewrite this to "zho".
+  if (language_code.size() != 2) {
+    return language_code;
+  }
+  const char* three_letter_code = uloc_getISO3Language(
+      language_code.c_str());
+  if (three_letter_code && strlen(three_letter_code) > 0) {
+    return three_letter_code;
+  }
+  return language_code;
+}
+
 }  // namespace chromeos