Sort input methods names in the language selector by language names.

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 <functional>
 #include <utility>
 #include <vector>
@@ skipping 807 matching lines @@
   if (activated) {
     // Add |id| if it's not already added.
     input_method_id_set.insert(input_method_id);
   } else {
     input_method_id_set.erase(input_method_id);
   }
 
   // Update Chrome's preference.
   std::vector<std::string> new_input_method_ids(input_method_id_set.begin(),
                                                 input_method_id_set.end());
+
+  // Note: Since |new_input_method_ids| is alphabetically sorted and the sort
+  // function below uses stable sort, the relateve order of input methods that
+  // belong to the same language (e.g. "mozc" and "xkb:jp::jpn") is maintained.
+  SortInputMethodIdsByNames(id_to_language_code_map_, &new_input_method_ids);
   preload_engines_.SetValue(UTF8ToWide(JoinString(new_input_method_ids, ',')));
 }
 
 bool LanguageConfigView::InputMethodIsActivated(
     const std::string& input_method_id) {
   std::vector<std::string> input_method_ids;
   GetActiveInputMethodIds(&input_method_ids);
   return (std::find(input_method_ids.begin(), input_method_ids.end(),
                     input_method_id) != input_method_ids.end());
 }
@@ skipping 95 matching lines @@
 
 std::wstring LanguageConfigView::GetLanguageDisplayNameFromCode(
     const std::string& language_code) {
   return MaybeRewriteLanguageName(UTF16ToWide(
       l10n_util::GetDisplayNameForLocale(
           language_code, g_browser_process->GetApplicationLocale(),
           true)));
 }
 
 namespace {
+
 // The comparator is used for sorting language codes by their
 // corresponding language names, using the ICU collator.
-struct CompareByLanguageName : std::binary_function<const std::string&,
-                                                    const std::string&,
-                                                    bool> {
-  CompareByLanguageName(icu::Collator* collator)
+struct CompareLanguageCodesByLanguageName
+    : std::binary_function<const std::string&, const std::string&, bool> {
+  explicit CompareLanguageCodesByLanguageName(icu::Collator* collator)
       : collator_(collator) {
   }
 
   // Calling GetLanguageDisplayNameFromCode() in the comparator is not
   // efficient, but acceptable as the function is cheap, and the language
   // list is short (about 40 at most).
   bool operator()(const std::string& s1, const std::string& s2) const {
     const std::wstring key1 =
             LanguageConfigView::GetLanguageDisplayNameFromCode(s1);
     const std::wstring key2 =
             LanguageConfigView::GetLanguageDisplayNameFromCode(s2);
     return l10n_util::StringComparator<std::wstring>(collator_)(key1, key2);
   }
+
   icu::Collator* collator_;
 };
+
+// The comparator is used for sorting input method ids by their
+// corresponding language names, using the ICU collator.
+struct CompareInputMethodIdsByLanguageName
+    : std::binary_function<const std::string&, const std::string&, bool> {
+  CompareInputMethodIdsByLanguageName(
+      icu::Collator* collator,
+      const std::map<std::string, std::string>& id_to_language_code_map)
+      : comparator_(collator),
+        id_to_language_code_map_(id_to_language_code_map) {
+  }
+
+  bool operator()(const std::string& s1, const std::string& s2) const {
+    std::string language_code_1;
+    std::map<std::string, std::string>::const_iterator iter =
+        id_to_language_code_map_.find(s1);
+    if (iter != id_to_language_code_map_.end()) {
+      language_code_1 = iter->second;
+    }
+    std::string language_code_2;
+    iter = id_to_language_code_map_.find(s2);
+    if (iter != id_to_language_code_map_.end()) {
+      language_code_2 = iter->second;
+    }
+    return comparator_(language_code_1, language_code_2);
+  }
+
+  const CompareLanguageCodesByLanguageName comparator_;
+  const std::map<std::string, std::string>& id_to_language_code_map_;
+};
+
 }  // namespace
 
 void LanguageConfigView::SortLanguageCodesByNames(
     std::vector<std::string>* language_codes) {
   // We should build collator outside of the comparator. We cannot have
   // scoped_ptr<> in the comparator for a subtle STL reason.
   UErrorCode error = U_ZERO_ERROR;
   icu::Locale locale(g_browser_process->GetApplicationLocale().c_str());
   scoped_ptr<icu::Collator> collator(
       icu::Collator::createInstance(locale, error));
-  if (U_FAILURE(error))
+  if (U_FAILURE(error)) {
     collator.reset();
+  }
   std::sort(language_codes->begin(), language_codes->end(),
-            CompareByLanguageName(collator.get()));
+            CompareLanguageCodesByLanguageName(collator.get()));
+}
+
+void LanguageConfigView::SortInputMethodIdsByNames(
+    const std::map<std::string, std::string>& id_to_language_code_map,
+    std::vector<std::string>* input_method_ids) {
+  UErrorCode error = U_ZERO_ERROR;
+  icu::Locale locale(g_browser_process->GetApplicationLocale().c_str());
+  scoped_ptr<icu::Collator> collator(
+      icu::Collator::createInstance(locale, error));
+  if (U_FAILURE(error)) {
+    collator.reset();
+  }
+  std::stable_sort(input_method_ids->begin(), input_method_ids->end(),
+                   CompareInputMethodIdsByLanguageName(
+                       collator.get(), id_to_language_code_map));
 }
 
 void LanguageConfigView::ReorderInputMethodIdsForLanguageCode(
     const std::string& language_code,
     std::vector<std::string>* input_method_ids) {
   for (size_t i = 0; i < arraysize(kLanguageDefaultInputMethodIds); ++i) {
     if (language_code == kLanguageDefaultInputMethodIds[i].language_code) {
       std::vector<std::string>::iterator iter =
           std::find(input_method_ids->begin(), input_method_ids->end(),
                     kLanguageDefaultInputMethodIds[i].input_method_id);
       // If it's not on the top of |input_method_id|, swap it with the top one.
       if (iter != input_method_ids->end() &&
           iter != input_method_ids->begin()) {
         std::swap(*input_method_ids->begin(), *iter);
       }
       break;  // Don't have to check other language codes.
     }
   }
 }
 
 }  // namespace chromeos