[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>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
 // For SetHardwareKeyboardLayoutForTesting.
 #include "chromeos/ime/fake_input_method_delegate.h"
 #include "chromeos/ime/input_method_delegate.h"
+#include "chromeos/ime/input_method_whitelist.h"
 // TODO(nona): move this header from this file.
 #include "grit/generated_resources.h"
 
 namespace {
 
 // A mapping from an input method id to a string for the language indicator. The
 // mapping is necessary since some input methods belong to the same language.
 // For example, both "xkb:us::eng" and "xkb:us:dvorak:eng" are for US English.
 const struct {
   const char* input_method_id;
@@ skipping 86 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] = {{"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 145 matching lines @@
 const size_t kEnglishToResourceIdArraySize =
     arraysize(kEnglishToResourceIdArray);
 
 }  // namespace
 
 InputMethodUtil::InputMethodUtil(
     InputMethodDelegate* delegate,
     scoped_ptr<InputMethodDescriptors> supported_input_methods)
     : supported_input_methods_(supported_input_methods.Pass()),
       delegate_(delegate) {
+  // Makes sure the supported input methods at least have the fallback ime.
+  // So that it won't cause massive test failures.
+  if (supported_input_methods_->empty())
+    supported_input_methods_->push_back(GetFallbackInputMethodDescriptor());
+
   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 56 matching lines @@
 
     text = language_name + base::UTF8ToUTF16(" - ") + text;
   }
 
   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;
-  }
+  InputMethodIdToDescriptorMap::const_iterator iter =
+      id_to_descriptor_.find(input_method_id);
+  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;
+
+    typedef LanguageCodeToIdsMap::const_iterator It;
+    for (size_t j = 0; j < language_codes.size(); ++j) {
+      std::pair<It, It> range =
+          language_code_to_ids_.equal_range(language_codes[j]);
+      It it = range.first;
+      for (; it != range.second; ++it) {
+        if (it->second == input_method.id())
+          break;
+      }
+      if (it == range.second)
+        language_code_to_ids_.insert(
+            std::make_pair(language_codes[j], input_method.id()));
+    }
   }
 }
 
+void InputMethodUtil::InitXkbInputMethodsForTesting() {
+  if (!extension_ime_util::UseWrappedExtensionKeyboardLayouts())
+    return;
+  scoped_ptr<InputMethodDescriptors> original_imes =
+      InputMethodWhitelist().GetSupportedInputMethods();
+  InputMethodDescriptors whitelist_imes;
+  for (size_t i = 0; i < original_imes->size(); ++i) {
+    const InputMethodDescriptor& ime = (*original_imes)[i];
+    whitelist_imes.push_back(InputMethodDescriptor(
+        extension_ime_util::GetInputMethodIDByKeyboardLayout(ime.id()),
+        "",
+        ime.indicator(),
+        ime.keyboard_layouts(),
+        ime.language_codes(),
+        ime.is_login_keyboard(),
+        ime.options_page_url(),
+        ime.input_view_url()));
+  }
+  SetComponentExtensions(whitelist_imes);
+}
+
 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"),
       "",
       "US",
       layouts,
@@ skipping 32 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