Remove the flag g_use_wrapped_extension_keyboard_layouts.

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 13 matching lines @@
 #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;
+  const char* engine_id;
   const char* indicator_text;
 } kMappingFromIdToIndicatorText[] = {
   // To distinguish from "xkb:jp::jpn"
   // TODO(nona): Make following variables configurable. http://crbug.com/232260.
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_us", "\xe3\x81\x82" },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_jp", "\xe3\x81\x82" },
-  { "_comp_ime_bbaiamgfapehflhememkfglaehiobjnknacl_mozc_us", "\xe3\x81\x82" },
-  { "_comp_ime_bbaiamgfapehflhememkfglaehiobjnknacl_mozc_jp", "\xe3\x81\x82" },
+  { "nacl_mozc_us", "\xe3\x81\x82" },
+  { "nacl_mozc_jp", "\xe3\x81\x82" },
   // For simplified Chinese input methods
-  { "pinyin", "\xe6\x8b\xbc" },  // U+62FC
-  { "_comp_ime_cpgalbafkoofkjmaeonnfijgpfennjjnzh-t-i0-pinyin",
-    "\xe6\x8b\xbc" },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin",
-    "\xe6\x8b\xbc" },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-wubi-1986",
-    "\xe4\xba\x94" }, // U+4E94
-  { "pinyin-dv", "\xe6\x8b\xbc" },
+  { "zh-t-i0-pinyin", "\xe6\x8b\xbc" },  // U+62FC
+  { "zh-t-i0-wubi-1986", "\xe4\xba\x94" }, // U+4E94
   // For traditional Chinese input methods
-  { "mozc-chewing", "\xe9\x85\xb7" },  // U+9177
-  { "_comp_ime_ekbifjdfhkmdeeajnolmgdlmkllopefizh-hant-t-i0-und",
-    "\xE6\xB3\xA8" },  // U+6CE8
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-und",
-    "\xE6\xB3\xA8" },  // U+6CE8
-  { "m17n:zh:cangjie", "\xe5\x80\x89" },  // U+5009
-  { "_comp_ime_aeebooiibjahgpgmhkeocbeekccfknbjzh-hant-t-i0-cangjie-1987",
-    "\xe5\x80\x89" },  // U+5009
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-cangjie-1987",
-    "\xe5\x80\x89" },  // U+5009
-  { "m17n:zh:quick", "\xe9\x80\x9f" },  // U+901F
+  { "zh-hant-t-i0-und", "\xE6\xB3\xA8" },  // U+9177
+  { "zh-hant-t-i0-cangjie-1987", "\xe5\x80\x89" },  // U+5009
+  { "zh-hant-t-i0-cangjie-1987-x-m0-simplified", "\xe9\x80\x9f" },  // U+901F
   // For Hangul input method.
-  { "mozc-hangul", "\xed\x95\x9c" },  // U+D55C
-  { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_2set", "\xed\x95\x9c" },
-  { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3set390",
-    "\xed\x95\x9c" },
-  { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setfinal",
-    "\xed\x95\x9c" },
-  { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setnoshift",
-    "\xed\x95\x9c" },
-  { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_romaja", "\xed\x95\x9c" },
+  { "hangul_2set", "\xed\x95\x9c" },  // U+D55C
+  { "hangul_3set390", "\xed\x95\x9c" },  // U+D55C
+  { "hangul_3setfinal", "\xed\x95\x9c" },  // U+D55C
+  { "hangul_3setnoshift", "\xed\x95\x9c" },  // U+D55C
+  { "hangul_romaja", "\xed\x95\x9c" },  // U+D55C
   { extension_misc::kBrailleImeEngineId,
     // U+2803 U+2817 U+2807 (Unicode braille patterns for the letters 'brl' in
     // English (and many other) braille codes.
     "\xe2\xa0\x83\xe2\xa0\x97\xe2\xa0\x87" },
 };
 
 const size_t kMappingFromIdToIndicatorTextLen =
     ARRAYSIZE_UNSAFE(kMappingFromIdToIndicatorText);
 
 // A mapping from an input method id to a resource id for a
 // medium length language indicator.
 // For those languages that want to display a slightly longer text in the
 // "Your input method has changed to..." bubble than in the status tray.
 // If an entry is not found in this table the short name is used.
 const struct {
-  const char* input_method_id;
+  const char* engine_id;
   const int resource_id;
 } kMappingImeIdToMediumLenNameResourceId[] = {
-  { "m17n:zh:cangjie", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "m17n:zh:quick", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "mozc-chewing", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "mozc-hangul", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
-  { "pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
-  { "pinyin-dv", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
-  { "_comp_ime_cpgalbafkoofkjmaeonnfijgpfennjjnzh-t-i0-pinyin",
-    IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED},
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin",
-    IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-wubi-1986",
-    IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
-  { "_comp_ime_ekbifjdfhkmdeeajnolmgdlmkllopefizh-hant-t-i0-und",
+  { "hangul_2set", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
+  { "hangul_3set390", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
+  { "hangul_3setfinal", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
+  { "hangul_3setnoshift", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
+  { "hangul_3setromaja", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
+  { "zh-t-i0-pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED},
+  { "zh-t-i0-wubi-1986", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
+  { "zh-hant-t-i0-und", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
+  { "zh-hant-t-i0-cangjie-1987",
     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-und",
-    IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "_comp_ime_aeebooiibjahgpgmhkeocbeekccfknbjzh-hant-t-i0-cangjie-1987",
-    IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-cangjie-1987",
+  { "zh-hant-t-i0-cangjie-1987-x-m0-simplified",
     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
   { extension_misc::kBrailleImeEngineId,
     IDS_LANGUAGES_MEDIUM_LEN_NAME_BRAILLE },
 };
 const size_t kMappingImeIdToMediumLenNameResourceIdLen =
     ARRAYSIZE_UNSAFE(kMappingImeIdToMediumLenNameResourceId);
 
 // Due to asynchronous initialization of component extension manager,
 // GetFirstLogingInputMethodIds may miss component extension IMEs. To enable
 // component extension IME as the first loging input method, we have to prepare
 // component extension IME IDs.
 const struct {
   const char* locale;
   const char* layout;
-  const char* input_method_id;
+  const char* engine_id;
 } kDefaultInputMethodRecommendation[] = {
-  { "ja", "us", "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_us" },
-  { "ja", "jp", "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_jp" },
-  { "zh-CN", "us", "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin" },
-  { "zh-TW", "us",
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-und" },
-#if defined(OFFICIAL_BUILD)
-  { "th", "us", "_comp_ime_habcdindjejkmepknlhkkloncjcpcnbfvkd_th" },
-  { "vi", "us", "_comp_ime_habcdindjejkmepknlhkkloncjcpcnbfvkd_vi_tcvn" },
-  { "vi", "us", "_comp_ime_habcdindjejkmepknlhkkloncjcpcnbfvkd_vi_tcvn" },
-#else
-  { "th", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_th" },
-  { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
-  { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
-#endif
+  { "ja", "us", "nacl_mozc_us" },
+  { "ja", "jp", "nacl_mozc_jp" },
+  { "zh-CN", "us", "zh-t-i0-pinyin" },
+  { "zh-TW", "us", "zh-hant-t-i0-und" },
+  { "th", "us", "vkd_th" },
+  { "vi", "us", "vkd_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"},
@@ skipping 319 matching lines @@
   // "US" and "JP".
 
   // Use the indicator string if set.
   if (!input_method.indicator().empty()) {
     return base::UTF8ToUTF16(input_method.indicator());
   }
 
   base::string16 text;
   // Check special cases first.
   for (size_t i = 0; i < kMappingFromIdToIndicatorTextLen; ++i) {
-    if (kMappingFromIdToIndicatorText[i].input_method_id ==
-        input_method.id()) {
+    if (extension_ime_util::GetInputMethodIDByEngineID(
+        kMappingFromIdToIndicatorText[i].engine_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())) {
     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())
@@ skipping 16 matching lines @@
   DCHECK(!text.empty()) << input_method.id();
   return text;
 }
 
 base::string16 InputMethodUtil::GetInputMethodMediumName(
     const InputMethodDescriptor& input_method) const {
   // For the "Your input method has changed to..." bubble. In most cases
   // it uses the same name as the short name, unless found in a table
   // for medium length names.
   for (size_t i = 0; i < kMappingImeIdToMediumLenNameResourceIdLen; ++i) {
-    if (kMappingImeIdToMediumLenNameResourceId[i].input_method_id ==
+    if (extension_ime_util::GetInputMethodIDByEngineID(
+        kMappingImeIdToMediumLenNameResourceId[i].engine_id) ==
         input_method.id()) {
       return delegate_->GetLocalizedString(
           kMappingImeIdToMediumLenNameResourceId[i].resource_id);
     }
   }
   return GetInputMethodShortName(input_method);
 }
 
 base::string16 InputMethodUtil::GetInputMethodLongName(
     const InputMethodDescriptor& input_method) const {
@@ skipping 88 matching lines @@
   // First, add the current keyboard layout (one used on the login screen).
   out_input_method_ids->push_back(current_input_method.id());
 
   const std::string current_layout
       = current_input_method.GetPreferredKeyboardLayout();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultInputMethodRecommendation);
        ++i) {
     if (kDefaultInputMethodRecommendation[i].locale == language_code &&
         kDefaultInputMethodRecommendation[i].layout == current_layout) {
       out_input_method_ids->push_back(
-          kDefaultInputMethodRecommendation[i].input_method_id);
+          extension_ime_util::GetInputMethodIDByEngineID(
+              kDefaultInputMethodRecommendation[i].engine_id));
       return;
     }
   }
 
   // Second, find the most popular input method associated with the
   // current UI language. The input method IDs returned from
   // GetInputMethodIdsFromLanguageCode() are sorted by popularity, hence
   // our basic strategy is to pick the first one, but it's a bit more
   // complicated as shown below.
   std::string most_popular_id;
@@ skipping 64 matching lines @@
 
   return std::string();
 }
 
 bool InputMethodUtil::MigrateInputMethods(
     std::vector<std::string>* input_method_ids) {
   bool rewritten = false;
   std::vector<std::string>& ids = *input_method_ids;
   for (size_t i = 0; i < ids.size(); ++i) {
     std::string id =
-        extension_ime_util::GetInputMethodIDByKeyboardLayout(ids[i]);
+        extension_ime_util::GetInputMethodIDByEngineID(ids[i]);
     // Migrates old ime id's to new ones.
     for (size_t j = 0; j < arraysize(kExtensionIdMigrationMap); ++j) {
       size_t pos = id.find(kExtensionIdMigrationMap[j][0]);
       if (pos != std::string::npos)
         id.replace(pos, kExtensionIdLen, kExtensionIdMigrationMap[j][1]);
       if (id != ids[i]) {
         ids[i] = id;
         rewritten = true;
       }
     }
@@ skipping 92 matching lines @@
   // Clear the existing maps.
   language_code_to_ids_.clear();
   id_to_language_code_.clear();
   id_to_descriptor_.clear();
 
   AppendInputMethods(imes);
 }
 
 void InputMethodUtil::InitXkbInputMethodsForTesting() {
   cached_hardware_layouts_.clear();
-  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()),
+        extension_ime_util::GetInputMethodIDByEngineID(ime.id()),
         "",
         ime.indicator(),
         ime.keyboard_layouts(),
         ime.language_codes(),
         ime.is_login_keyboard(),
         ime.options_page_url(),
         ime.input_view_url()));
   }
   ResetInputMethods(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"),
+      extension_ime_util::GetInputMethodIDByEngineID("xkb:us::eng"),
       "",
       "US",
       layouts,
       languages,
       true,  // login keyboard.
       GURL(),  // options page, not available.
       GURL()); // input view page, not available.
 }
 
 void InputMethodUtil::ReloadInternalMaps() {
   if (supported_input_methods_->size() <= 1) {
     DVLOG(1) << "GetSupportedInputMethods returned a fallback ID";
     // TODO(yusukes): Handle this error in nicer way.
   }
 
   // Clear the existing maps.
   language_code_to_ids_.clear();
   id_to_language_code_.clear();
   id_to_descriptor_.clear();
 
   for (size_t i = 0; i < supported_input_methods_->size(); ++i) {
     const InputMethodDescriptor& input_method = supported_input_methods_->at(i);
     const std::string input_method_id =
-        extension_ime_util::GetInputMethodIDByKeyboardLayout(input_method.id());
+        extension_ime_util::GetInputMethodIDByEngineID(input_method.id());
     const std::vector<std::string>& language_codes =
         input_method.language_codes();
 
     // |input_method_id| may be different than input_method.id().
     id_to_descriptor_.insert(
         std::make_pair(input_method_id,
                        InputMethodDescriptor(input_method_id,
                                              input_method.name(),
                                              input_method.indicator(),
                                              input_method.keyboard_layouts(),
                                              input_method.language_codes(),
                                              input_method.is_login_keyboard(),
                                              input_method.options_page_url(),
                                              input_method.input_view_url())));
 
     for (size_t i = 0; i < language_codes.size(); ++i) {
       language_code_to_ids_.insert(
           std::make_pair(language_codes[i], input_method_id));
       // Remember the pairs.
       id_to_language_code_.insert(
           std::make_pair(input_method_id, language_codes[i]));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos