[IME] Removes the duplicated IMEs in chrome://settings/languages, and support async component IMEs …

chrome/browser/chromeos/input_method/input_method_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 "chrome/browser/chromeos/input_method/input_method_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <utility>
@@ skipping 108 matching lines @@
   { "ja", "us", "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us" },
   { "ja", "jp", "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp" },
   { "zh-CN", "us", "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin" },
   { "zh-TW", "us",
     "_comp_ime_goedamlknlnjaengojinmfgpmdjmkooozh-hant-t-i0-und" },
   { "th", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_th" },
   { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
   { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
 };
 
+// The map from xkb layout to the indicator text.
+// Refer to crbug.com/349829.
+const char* const kXkbIndicators[][2] = {

[Alexander Alekseev, 2014/03/07 13:19:31]

Will this be translated?

[Shu Chen, 2014/03/07 13:22:26]

Thanks for your quick review.

There is no need to translate these strings. It won't change the original
behaviors.

Please refer to
https://code.google.com/p/chromium/codesearch#chromium/src/chromeos/ime/input....
I was just partially copying that map.

+  {"am", "AM"},
+  {"be", "BE"},
+  {"bg", "BG"},
+  {"bg(phonetic)", "BG"},
+  {"br", "BR"},
+  {"by", "BY"},
+  {"ca", "CA"},
+  {"ca(eng)", "CA"},
+  {"ca(multix)", "CA"},
+  {"ch", "CH"},
+  {"ch(fr)", "CH"},
+  {"cz", "CZ"},
+  {"cz(qwerty)", "CS"},
+  {"de", "DE"},
+  {"de(neo)", "NEO"},
+  {"dk", "DK"},
+  {"ee", "EE"},
+  {"es", "ES"},
+  {"es(cat)", "CAS"},
+  {"fi", "FI"},
+  {"fr", "FR"},
+  {"gb(dvorak)", "DV"},
+  {"gb(extd)", "GB"},
+  {"ge", "GE"},
+  {"gr", "GR"},
+  {"hr", "HR"},
+  {"hu", "HU"},
+  {"il", "IL"},
+  {"is", "IS"},
+  {"it", "IT"},
+  {"jp", "JA"},
+  {"latam", "LA"},
+  {"lt", "LT"},
+  {"lv(apostrophe)", "LV"},
+  {"mn", "MN"},
+  {"no", "NO"},
+  {"pl", "PL"},
+  {"pt", "PT"},
+  {"ro", "RO"},
+  {"rs", "RS"},
+  {"ru", "RU"},
+  {"ru(phonetic)", "RU"},
+  {"se", "SE"},
+  {"si", "SI"},
+  {"sk", "SK"},
+  {"tr", "TR"},
+  {"ua", "UA"},
+  {"us", "US"},
+  {"us(altgr-intl)", "EXTD"},
+  {"us(colemak)", "CO"},
+  {"us(dvorak)", "DV"},
+  {"us(intl)", "INTL"},
+};
+
 }  // namespace
 
 namespace chromeos {
 
 extern const char* kExtensionImePrefix;
 
 namespace input_method {
 
 namespace {
 
@@ skipping 155 matching lines @@
   ReloadInternalMaps();
 
   // Initialize a map from English string to Chrome string resource ID as well.
   for (size_t i = 0; i < kEnglishToResourceIdArraySize; ++i) {
     const EnglishToResouceId& map_entry = kEnglishToResourceIdArray[i];
     const bool result = english_to_resource_id_.insert(std::make_pair(
         map_entry.english_string_from_ibus, map_entry.resource_id)).second;
     DCHECK(result) << "Duplicated string is found: "
                    << map_entry.english_string_from_ibus;
   }
+
+  // Initialize the map from xkb layout to indicator text.
+  for (size_t i = 0; i < arraysize(kXkbIndicators); ++i) {
+    xkb_layout_to_indicator_[kXkbIndicators[i][0]] =
+        kXkbIndicators[i][1];
+  }
 }
 
 InputMethodUtil::~InputMethodUtil() {
 }
 
 bool InputMethodUtil::TranslateStringInternal(
     const std::string& english_string, base::string16 *out_string) const {
   DCHECK(out_string);
   HashType::const_iterator iter = english_to_resource_id_.find(english_string);
   if (iter == english_to_resource_id_.end()) {
@@ skipping 77 matching lines @@
   // Check special cases first.
   for (size_t i = 0; i < kMappingFromIdToIndicatorTextLen; ++i) {
     if (kMappingFromIdToIndicatorText[i].input_method_id ==
         input_method.id()) {
       text = base::UTF8ToUTF16(kMappingFromIdToIndicatorText[i].indicator_text);
       break;
     }
   }
 
   // Display the keyboard layout name when using a keyboard layout.
-  if (text.empty() &&
-      IsKeyboardLayout(input_method.id())) {
-    const size_t kMaxKeyboardLayoutNameLen = 2;
-    const base::string16 keyboard_layout =
-        base::UTF8ToUTF16(GetKeyboardLayoutName(input_method.id()));
-    text = StringToUpperASCII(keyboard_layout).substr(
-        0, kMaxKeyboardLayoutNameLen);
+  if (text.empty() && IsKeyboardLayout(input_method.id())) {
+    std::map<std::string, std::string>::const_iterator it =
+        xkb_layout_to_indicator_.find(GetKeyboardLayoutName(
+            input_method.id()));
+    if (it != xkb_layout_to_indicator_.end())
+      text = base::UTF8ToUTF16(it->second);
   }
 
   // TODO(yusukes): Some languages have two or more input methods. For example,
   // Thai has 3, Vietnamese has 4. If these input methods could be activated at
   // the same time, we should do either of the following:
   //   (1) Add mappings to |kMappingFromIdToIndicatorText|
   //   (2) Add suffix (1, 2, ...) to |text| when ambiguous.
 
   if (text.empty()) {
     const size_t kMaxLanguageNameLen = 2;
@@ skipping 58 matching lines @@
   }
 
   DCHECK(!text.empty());
   return text;
 }
 
 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId(
     const std::string& input_method_id) const {
   InputMethodIdToDescriptorMap::const_iterator iter
       = id_to_descriptor_.find(input_method_id);
-  if (iter == id_to_descriptor_.end()) {
-    // If failed to find the descriptor for given id, it may because of the id
-    // is a component extension xkb id (_comp_ime_...xkb:...).
-    // So try to convert it to legacy xkb id and find again.
-    // This hack is mainly for OOBE session, which requires a sync call to get
-    // the input method descriptor for extension xkb id.
-    // TODO(shuchen): need to support async wait for component extension
-    // loading in OOBE session. This hack won't be needed when it's been done.
-    iter = id_to_descriptor_.find(
-        extension_ime_util::MaybeGetLegacyXkbId(input_method_id));
-    if (iter == id_to_descriptor_.end())
-      return NULL;
-  }
+  if (iter == id_to_descriptor_.end())
+    return NULL;
   return &(iter->second);
 }
 
 bool InputMethodUtil::GetInputMethodIdsFromLanguageCode(
     const std::string& normalized_language_code,
     InputMethodType type,
     std::vector<std::string>* out_input_method_ids) const {
   return GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_,
       normalized_language_code, type, out_input_method_ids);
@@ skipping 192 matching lines @@
 
 bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id)
     const {
   const InputMethodDescriptor* ime =
       GetInputMethodDescriptorFromId(input_method_id);
   return ime ? ime->is_login_keyboard() : false;
 }
 
 void InputMethodUtil::SetComponentExtensions(
     const InputMethodDescriptors& imes) {
-  component_extension_ime_id_to_descriptor_.clear();
   for (size_t i = 0; i < imes.size(); ++i) {
-    const InputMethodDescriptor& input_method = imes.at(i);
+    const InputMethodDescriptor& input_method = imes[i];
     DCHECK(!input_method.language_codes().empty());
-    const std::string language_code = input_method.language_codes().at(0);
-    id_to_language_code_.insert(
-        std::make_pair(input_method.id(), language_code));
-    id_to_descriptor_.insert(
-        std::make_pair(input_method.id(), input_method));
+    const std::vector<std::string>& language_codes =
+        input_method.language_codes();
+    id_to_language_code_[input_method.id()] = language_codes[0];
+    id_to_descriptor_[input_method.id()] = input_method;
+    for (size_t j = 0; j < language_codes.size(); ++j) {
+      language_code_to_ids_.insert(
+          std::make_pair(language_codes[j], input_method.id()));
+    }
   }
 }
 
 InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
   std::vector<std::string> layouts;
   layouts.push_back("us");
   std::vector<std::string> languages;
   languages.push_back("en-US");
   return InputMethodDescriptor(
       extension_ime_util::GetInputMethodIDByKeyboardLayout("xkb:us::eng"),
@@ skipping 35 matching lines @@
     if (IsKeyboardLayout(input_method.id())) {
       xkb_id_to_descriptor_.insert(
           std::make_pair(input_method.GetPreferredKeyboardLayout(),
                          input_method));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos