[IME] Remove the flag g_use_wrapped_extension_keyboard_layouts, and clean up the scattered & hard-coded extension IDs.

BUG=379437,379449
TEST=None

Review URL: https://codereview.chromium.org/309623005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@274480 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 327 insertions, 432 deletions

diff --git a/chrome/browser/chromeos/extensions/input_method_api.cc b/chrome/browser/chromeos/extensions/input_method_api.cc
index 5380fb6..582f8e1 100644
--- a/chrome/browser/chromeos/extensions/input_method_api.cc
+++ b/chrome/browser/chromeos/extensions/input_method_api.cc
@@ -80,8 +80,7 @@ InputMethodAPI::~InputMethodAPI() {
 // static
 std::string InputMethodAPI::GetInputMethodForXkb(const std::string& xkb_id) {
   std::string xkb_prefix =
-      chromeos::extension_ime_util::GetInputMethodIDByKeyboardLayout(
-          kXkbPrefix);
+      chromeos::extension_ime_util::GetInputMethodIDByEngineID(kXkbPrefix);
   size_t prefix_length = xkb_prefix.length();
   DCHECK(xkb_id.substr(0, prefix_length) == xkb_prefix);
   return xkb_id.substr(prefix_length);
diff --git a/chrome/browser/chromeos/extensions/input_method_apitest_chromeos.cc b/chrome/browser/chromeos/extensions/input_method_apitest_chromeos.cc
index 5ae8790..5fa5e5b 100644
--- a/chrome/browser/chromeos/extensions/input_method_apitest_chromeos.cc
+++ b/chrome/browser/chromeos/extensions/input_method_apitest_chromeos.cc
@@ -58,7 +58,7 @@ class SetInputMethodListener : public content::NotificationObserver {
 
       std::vector<std::string> keyboard_layouts;
       keyboard_layouts.push_back(
-          chromeos::extension_ime_util::GetInputMethodIDByKeyboardLayout(
+          chromeos::extension_ime_util::GetInputMethodIDByEngineID(
               kInitialInputMethodOnLoginScreen));
       manager->EnableLoginLayouts(kLoginScreenUILanguage, keyboard_layouts);
       return;
@@ -68,7 +68,7 @@ class SetInputMethodListener : public content::NotificationObserver {
         base::StringPrintf("%s:%s", kSetInputMethodMessage, kNewInputMethod);
     if (content == expected_message) {
       chromeos::input_method::InputMethodManager::Get()->ChangeInputMethod(
-          chromeos::extension_ime_util::GetInputMethodIDByKeyboardLayout(
+          chromeos::extension_ime_util::GetInputMethodIDByEngineID(
               base::StringPrintf("xkb:%s", kNewInputMethod)));
 
       scoped_refptr<extensions::TestSendMessageFunction> function =
diff --git a/chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc b/chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc
index deac95a..4db6df6 100644
--- a/chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc
+++ b/chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc
@@ -14,6 +14,7 @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
+#include "chromeos/ime/extension_ime_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
@@ -32,56 +33,56 @@ struct WhitelistedComponentExtensionIME {
 } whitelisted_component_extension[] = {
   {
     // ChromeOS Hangul Input.
-    "bdgdidmhaijohebebipajioienkglgfo",
+    extension_ime_util::kHangulExtensionId,
     "/usr/share/chromeos-assets/input_methods/hangul",
   },
+  {
+    // Official Google Japanese Input.
+    extension_ime_util::kMozcExtensionId,
+    "/usr/share/chromeos-assets/input_methods/nacl_mozc",
+  },
 #if defined(OFFICIAL_BUILD)
   {
     // Official Google XKB Input.
-    "jkghodnilhceideoidjikpgommlajknk",
+    extension_ime_util::kXkbExtensionId,
     "/usr/share/chromeos-assets/input_methods/google_xkb",
   },
   {
     // Official Google Keyboards Input.
-    "habcdindjejkmepknlhkkloncjcpcnbf",
+    extension_ime_util::kM17nExtensionId,
     "/usr/share/chromeos-assets/input_methods/google_keyboards",
   },
   {
     // Google input tools.
-    "gjaehgfemfahhmlgpdfknkhdnemmolop",
+    extension_ime_util::kT13nExtensionId,
     "/usr/share/chromeos-assets/input_methods/input_tools",
   },
 #else
   {
     // Open-sourced ChromeOS xkb extension.
-    "fgoepimhcoialccpbmpnnblemnepkkao",
+    extension_ime_util::kXkbExtensionId,
     "/usr/share/chromeos-assets/input_methods/xkb",
   },
   {
     // Open-sourced ChromeOS Keyboards extension.
-    "jhffeifommiaekmbkkjlpmilogcfdohp",
+    extension_ime_util::kM17nExtensionId,
     "/usr/share/chromeos-assets/input_methods/keyboard_layouts",
   },
   {
     // Open-sourced Pinyin Chinese Input Method.
-    "cpgalbafkoofkjmaeonnfijgpfennjjn",
+    extension_ime_util::kChinesePinyinExtensionId,
     "/usr/share/chromeos-assets/input_methods/pinyin",
   },
   {
     // Open-sourced Zhuyin Chinese Input Method.
-    "ekbifjdfhkmdeeajnolmgdlmkllopefi",
+    extension_ime_util::kChineseZhuyinExtensionId,
     "/usr/share/chromeos-assets/input_methods/zhuyin",
   },
   {
     // Open-sourced Cangjie Chinese Input Method.
-    "aeebooiibjahgpgmhkeocbeekccfknbj",
+    extension_ime_util::kChineseCangjieExtensionId,
     "/usr/share/chromeos-assets/input_methods/cangjie",
   },
-  {
-    // Open-sourced Mozc Japanese Input.
-    "bbaiamgfapehflhememkfglaehiobjnk",
-    "/usr/share/chromeos-assets/input_methods/nacl_mozc",
-  },
 #endif
   {
     // Braille hardware keyboard IME that works together with ChromeVox.
diff --git a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
index 58ddabe..5db7991 100644
--- a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
+++ b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
@@ -35,9 +35,6 @@ namespace input_method {
 
 namespace {
 
-const char nacl_mozc_jp_id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_jp";
-
 bool Contains(const std::vector<std::string>& container,
               const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
@@ -115,7 +112,7 @@ scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetSupportedInputMethods() const {
   scoped_ptr<InputMethodDescriptors> whitelist_imes =
       whitelist_.GetSupportedInputMethods();
-  if (!extension_ime_util::UseWrappedExtensionKeyboardLayouts())
+  if (!component_extension_ime_manager_->IsInitialized())
     return whitelist_imes.Pass();
   return scoped_ptr<InputMethodDescriptors>(new InputMethodDescriptors).Pass();
 }
@@ -229,8 +226,7 @@ void InputMethodManagerImpl::EnableLoginLayouts(
 
   // you can pass empty |initial_layout|.
   ChangeInputMethod(initial_layouts.empty() ? "" :
-      extension_ime_util::GetInputMethodIDByKeyboardLayout(
-          initial_layouts[0]));
+      extension_ime_util::GetInputMethodIDByEngineID(initial_layouts[0]));
 }
 
 // Adds new input method to given list.
@@ -670,15 +666,19 @@ bool InputMethodManagerImpl::SwitchInputMethod(
   std::vector<std::string> input_method_ids_to_switch;
   switch (accelerator.key_code()) {
     case ui::VKEY_CONVERT:  // Henkan key on JP106 keyboard
-      input_method_ids_to_switch.push_back(nacl_mozc_jp_id);
+      input_method_ids_to_switch.push_back(
+          extension_ime_util::GetInputMethodIDByEngineID("nacl_mozc_jp"));
       break;
     case ui::VKEY_NONCONVERT:  // Muhenkan key on JP106 keyboard
-      input_method_ids_to_switch.push_back("xkb:jp::jpn");
+      input_method_ids_to_switch.push_back(
+          extension_ime_util::GetInputMethodIDByEngineID("xkb:jp::jpn"));
       break;
     case ui::VKEY_DBE_SBCSCHAR:  // ZenkakuHankaku key on JP106 keyboard
     case ui::VKEY_DBE_DBCSCHAR:
-      input_method_ids_to_switch.push_back(nacl_mozc_jp_id);
-      input_method_ids_to_switch.push_back("xkb:jp::jpn");
+      input_method_ids_to_switch.push_back(
+          extension_ime_util::GetInputMethodIDByEngineID("nacl_mozc_jp"));
+      input_method_ids_to_switch.push_back(
+          extension_ime_util::GetInputMethodIDByEngineID("xkb:jp::jpn"));
       break;
     default:
       NOTREACHED();
@@ -689,8 +689,6 @@ bool InputMethodManagerImpl::SwitchInputMethod(
     return false;
   }
 
-  MigrateInputMethods(&input_method_ids_to_switch);
-
   // Obtain the intersection of input_method_ids_to_switch and
   // active_input_method_ids_. The order of IDs in active_input_method_ids_ is
   // preserved.
diff --git a/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc b/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
index d78658b..ba24c42 100644
--- a/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
+++ b/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
@@ -38,20 +38,11 @@ namespace chromeos {
 namespace input_method {
 namespace {
 
-const char kNaclMozcUsId[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_us";
-const char kNaclMozcJpId[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_jp";
-const char kExt2Engine1Id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine1_engine_id";
-const char kExt2Engine2Id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine2_engine_id";
-const char kXkbExtId[] =
-#if defined(OFFICIAL_BUILD)
-    "jkghodnilhceideoidjikpgommlajknk";
-#else
-    "fgoepimhcoialccpbmpnnblemnepkkao";
-#endif
+const char kNaclMozcUsId[] = "nacl_mozc_us";
+const char kNaclMozcJpId[] = "nacl_mozc_jp";
+const char kExt2Engine1Id[] = "ext2_engine1-t-i0-engine_id";
+const char kExt2Engine2Id[] = "ext2_engine2-t-i0-engine_id";
+const char kPinyinImeId[] = "zh-t-i0-pinyin";
 
 // Returns true if |descriptors| contain |target|.
 bool Contain(const InputMethodDescriptors& descriptors,
@@ -63,8 +54,8 @@ bool Contain(const InputMethodDescriptors& descriptors,
   return false;
 }
 
-std::string XkbId(const std::string& id) {
-  return extension_ime_util::GetInputMethodIDByKeyboardLayout(id);
+std::string ImeIdFromEngineId(const std::string& id) {
+  return extension_ime_util::GetInputMethodIDByEngineID(id);
 }
 
 class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
@@ -126,13 +117,13 @@ class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
     // Note, for production, these SetEngineHandler are called when
     // IMEEngineHandlerInterface is initialized via
     // InitializeComponentextension.
-    manager_->AddInputMethodExtension(kNaclMozcUsId,
+    manager_->AddInputMethodExtension(ImeIdFromEngineId(kNaclMozcUsId),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(kNaclMozcJpId,
+    manager_->AddInputMethodExtension(ImeIdFromEngineId(kNaclMozcJpId),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(kExt2Engine1Id,
+    manager_->AddInputMethodExtension(ImeIdFromEngineId(kExt2Engine1Id),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(kExt2Engine2Id,
+    manager_->AddInputMethodExtension(ImeIdFromEngineId(kExt2Engine2Id),
                                       mock_engine_handler_.get());
     manager_->InitializeComponentExtensionForTesting(delegate.Pass());
   }
@@ -141,7 +132,7 @@ class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
     ime_list_.clear();
 
     ComponentExtensionIME ext_xkb;
-    ext_xkb.id = kXkbExtId;
+    ext_xkb.id = extension_ime_util::kXkbExtensionId;
     ext_xkb.description = "ext_xkb_description";
     ext_xkb.path = base::FilePath("ext_xkb_file_path");
 
@@ -218,7 +209,7 @@ class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
     ime_list_.push_back(ext_xkb);
 
     ComponentExtensionIME ext1;
-    ext1.id = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+    ext1.id = extension_ime_util::kMozcExtensionId;
     ext1.description = "ext1_description";
     ext1.path = base::FilePath("ext1_file_path");
 
@@ -239,19 +230,19 @@ class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
     ime_list_.push_back(ext1);
 
     ComponentExtensionIME ext2;
-    ext2.id = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+    ext2.id = extension_ime_util::kT13nExtensionId;
     ext2.description = "ext2_description";
     ext2.path = base::FilePath("ext2_file_path");
 
     ComponentExtensionEngine ext2_engine1;
-    ext2_engine1.engine_id = "ext2_engine1_engine_id";
+    ext2_engine1.engine_id = kExt2Engine1Id;
     ext2_engine1.display_name = "ext2_engine_1_display_name";
     ext2_engine1.language_codes.push_back("en");
     ext2_engine1.layouts.push_back("us");
     ext2.engines.push_back(ext2_engine1);
 
     ComponentExtensionEngine ext2_engine2;
-    ext2_engine2.engine_id = "ext2_engine2_engine_id";
+    ext2_engine2.engine_id = kExt2Engine2Id;
     ext2_engine2.display_name = "ext2_engine_2_display_name";
     ext2_engine2.language_codes.push_back("en");
     ext2_engine2.layouts.push_back("us(dvorak)");
@@ -366,11 +357,11 @@ TEST_F(InputMethodManagerImplTest, TestObserver) {
   EXPECT_EQ(5U, manager_->GetActiveInputMethods()->size());
   EXPECT_EQ(1, observer.input_method_changed_count_);
   EXPECT_EQ(1, observer.input_method_menu_item_changed_count_);
-  manager_->ChangeInputMethod(XkbId("xkb:us:dvorak:eng"));
+  manager_->ChangeInputMethod(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_FALSE(observer.last_show_message_);
   EXPECT_EQ(2, observer.input_method_changed_count_);
   EXPECT_EQ(2, observer.input_method_menu_item_changed_count_);
-  manager_->ChangeInputMethod(XkbId("xkb:us:dvorak:eng"));
+  manager_->ChangeInputMethod(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_FALSE(observer.last_show_message_);
 
   // The observer is always notified even when the same input method ID is
@@ -389,25 +380,21 @@ TEST_F(InputMethodManagerImplTest, TestObserver) {
 TEST_F(InputMethodManagerImplTest, TestGetSupportedInputMethods) {
   InitComponentExtension();
   InputMethodDescriptors methods;
-  if (extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
-    methods = manager_->GetComponentExtensionIMEManager()
-                  ->GetXkbIMEAsInputMethodDescriptor();
-  } else {
-    methods = *(manager_->GetSupportedInputMethods());
-  }
+  methods = manager_->GetComponentExtensionIMEManager()
+                ->GetXkbIMEAsInputMethodDescriptor();
   // Try to find random 4-5 layuts and IMEs to make sure the returned list is
   // correct.
   const InputMethodDescriptor* id_to_find =
       manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-          kNaclMozcUsId);
+          ImeIdFromEngineId(kNaclMozcUsId));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-      XkbId("xkb:us::eng"));
+      ImeIdFromEngineId("xkb:us::eng"));
   EXPECT_TRUE(Contain(methods, *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-      XkbId("xkb:us:dvorak:eng"));
+      ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_TRUE(Contain(methods, *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-      XkbId("xkb:fr::fra"));
+      ImeIdFromEngineId("xkb:fr::fra"));
   EXPECT_TRUE(Contain(methods, *id_to_find));
 }
 
@@ -429,12 +416,12 @@ TEST_F(InputMethodManagerImplTest, TestEnableLayouts) {
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsAndCurrentInputMethod) {
   // For http://crbug.com/329061
   std::vector<std::string> keyboard_layouts;
-  keyboard_layouts.push_back(XkbId("xkb:se::swe"));
+  keyboard_layouts.push_back(ImeIdFromEngineId("xkb:se::swe"));
 
   InitComponentExtension();
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   const std::string im_id = manager_->GetCurrentInputMethod().id();
-  EXPECT_EQ(XkbId("xkb:se::swe"), im_id);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:se::swe"), im_id);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsNonUsHardwareKeyboard) {
@@ -463,7 +450,7 @@ TEST_F(InputMethodManagerImplTest, TestEnableLayoutsNonUsHardwareKeyboard) {
       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
   // "xkb:us::eng" only.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId("xkb:us::eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
             manager_->GetActiveInputMethodIds().front());
 }
 
@@ -503,10 +490,10 @@ TEST_F(InputMethodManagerImplTest, TestActiveInputMethods) {
   EXPECT_EQ(2U, methods->size());
   const InputMethodDescriptor* id_to_find =
       manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-          XkbId("xkb:us::eng"));
+          ImeIdFromEngineId("xkb:us::eng"));
   EXPECT_TRUE(id_to_find && Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
-      XkbId("xkb:jp::jpn"));
+      ImeIdFromEngineId("xkb:jp::jpn"));
   EXPECT_TRUE(id_to_find && Contain(*methods.get(), *id_to_find));
 }
 
@@ -517,21 +504,21 @@ TEST_F(InputMethodManagerImplTest, TestEnableTwoLayouts) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(XkbId("xkb:us:colemak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:colemak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   // Since all the IDs added avobe are keyboard layouts, Start() should not be
   // called.
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]),  // colemak
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]),  // colemak
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
@@ -544,25 +531,25 @@ TEST_F(InputMethodManagerImplTest, TestEnableThreeLayouts) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us::eng"));
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(XkbId("xkb:us:colemak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:colemak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   // Switch to Dvorak.
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Disable Dvorak.
   ids.erase(ids.begin() + 1);
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(3, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]),  // US Qwerty
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]),  // US Qwerty
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
@@ -575,22 +562,22 @@ TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(kNaclMozcUsId);
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Switch to Mozc
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   // Disable Mozc.
   ids.erase(ids.begin() + 1);
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 }
 
@@ -601,18 +588,18 @@ TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme2) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(kNaclMozcUsId);
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId(ids[0]),  // Mozc
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]),  // Mozc
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
@@ -624,11 +611,11 @@ TEST_F(InputMethodManagerImplTest, TestEnableImes) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(kExt2Engine1Id);
+  ids.push_back(ImeIdFromEngineId(kExt2Engine1Id));
   ids.push_back("mozc-dv");
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
@@ -656,35 +643,35 @@ TEST_F(InputMethodManagerImplTest, TestEnableLayoutsThenLock) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us::eng"));
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Switch to Dvorak.
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Lock screen
   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId(ids[1]),  // still Dvorak
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]),  // still Dvorak
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Switch back to Qwerty.
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Unlock screen. The original state, Dvorak, is restored.
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
@@ -697,36 +684,36 @@ TEST_F(InputMethodManagerImplTest, SwitchInputMethodTest) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(kExt2Engine2Id);
-  ids.push_back(kExt2Engine1Id);
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId(kExt2Engine2Id));
+  ids.push_back(ImeIdFromEngineId(kExt2Engine1Id));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Switch to Mozc.
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Lock screen
   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());  // Qwerty+Dvorak.
-  EXPECT_EQ(XkbId("xkb:us:dvorak:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:dvorak:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(XkbId("xkb:us::eng"),  // The hardware keyboard layout.
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),  // The hardware keyboard layout.
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Unlock screen. The original state, pinyin-dv, is restored.
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());  // Dvorak and 2 IMEs.
-  EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
@@ -737,10 +724,10 @@ TEST_F(InputMethodManagerImplTest, TestXkbSetting) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
-  ids.push_back(XkbId("xkb:us:colemak:eng"));
-  ids.push_back(kNaclMozcJpId);
-  ids.push_back(kNaclMozcUsId);
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:colemak:eng"));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcJpId));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(4U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, keyboard_->set_current_keyboard_layout_by_name_count_);
@@ -787,12 +774,12 @@ TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodProperties) {
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us::eng"));
-  ids.push_back(kNaclMozcUsId);
+  ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
-  manager_->ChangeInputMethod(kNaclMozcUsId);
+  manager_->ChangeInputMethod(ImeIdFromEngineId(kNaclMozcUsId));
 
   ash::ime::InputMethodMenuItemList current_property_list;
   current_property_list.push_back(ash::ime::InputMethodMenuItem(
@@ -813,8 +800,8 @@ TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(kNaclMozcUsId);  // Japanese
-  ids.push_back(kExt2Engine1Id);  // T-Chinese
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));   // Japanese
+  ids.push_back(ImeIdFromEngineId(kExt2Engine1Id));  // T-Chinese
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
@@ -830,7 +817,7 @@ TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
   EXPECT_EQ("key-mozc",
             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 
-  manager_->ChangeInputMethod(kExt2Engine1Id);
+  manager_->ChangeInputMethod(ImeIdFromEngineId(kExt2Engine1Id));
   // Since the IME is changed, the property for mozc Japanese should be hidden.
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
@@ -849,34 +836,37 @@ TEST_F(InputMethodManagerImplTest, TestNextInputMethod) {
   manager_->AddObserver(&observer);
   InitComponentExtension();
   std::vector<std::string> keyboard_layouts;
-  keyboard_layouts.push_back(XkbId("xkb:us::eng"));
+  keyboard_layouts.push_back(ImeIdFromEngineId("xkb:us::eng"));
   // For http://crbug.com/19655#c11 - (1)
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:intl:eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:altgr-intl:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:dvorak:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:dvorak:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:colemak:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:colemak:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
@@ -893,49 +883,55 @@ TEST_F(InputMethodManagerImplTest, TestPreviousInputMethod) {
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
   std::vector<std::string> keyboard_layouts;
-  keyboard_layouts.push_back(XkbId("xkb:us::eng"));
+  keyboard_layouts.push_back(ImeIdFromEngineId("xkb:us::eng"));
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:intl:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:intl:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:intl:eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:intl:eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:altgr-intl:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:intl:eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
-  EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us:altgr-intl:eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 
@@ -954,7 +950,7 @@ TEST_F(InputMethodManagerImplTest,
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 
@@ -967,12 +963,12 @@ TEST_F(InputMethodManagerImplTest,
 }
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithUsLayouts) {
-  std::string expect_id = XkbId("xkb:us::eng");
+  std::string expect_id = ImeIdFromEngineId("xkb:us::eng");
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   std::vector<std::string> keyboard_layouts;
-  keyboard_layouts.push_back(XkbId("xkb:us::eng"));
+  keyboard_layouts.push_back(ImeIdFromEngineId("xkb:us::eng"));
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
@@ -1011,30 +1007,36 @@ TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpLayout) {
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
   std::vector<std::string> keyboard_layouts;
-  keyboard_layouts.push_back(XkbId("xkb:us::eng"));
+  keyboard_layouts.push_back(ImeIdFromEngineId("xkb:us::eng"));
   manager_->EnableLoginLayouts("ja", keyboard_layouts);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
-  EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
 }
 
@@ -1042,48 +1044,58 @@ TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpIme) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:jp::jpn"));
-  ids.push_back(kNaclMozcJpId);
+  ids.push_back(ImeIdFromEngineId("xkb:jp::jpn"));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcJpId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcJpId),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
-  EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcJpId),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
-  EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcJpId),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
 
   // Add Dvorak.
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcJpId),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", keyboard_->last_layout_);
 }
 
@@ -1093,12 +1105,11 @@ TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us:dvorak:eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us:dvorak:eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]),
-            manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Add two Extension IMEs.
@@ -1175,11 +1186,11 @@ TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
   manager_->AddObserver(&observer);
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(XkbId("xkb:us::eng"));
+  ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Add an Extension IME.
@@ -1219,7 +1230,7 @@ TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
   // Lock the screen. This is for crosbug.com/27049.
   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());  // Qwerty. No Ext. IME
-  EXPECT_EQ(XkbId("xkb:us::eng"),
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", keyboard_->last_layout_);
 
@@ -1243,28 +1254,30 @@ TEST_F(InputMethodManagerImplTest,
        ChangeInputMethodBeforeComponentExtensionInitialization_OneIME) {
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(kNaclMozcUsId);
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
-  manager_->ChangeInputMethod(kNaclMozcUsId);
+  manager_->ChangeInputMethod(ImeIdFromEngineId(kNaclMozcUsId));
 
   InitComponentExtension();
-  EXPECT_EQ(kNaclMozcUsId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcUsId),
+            manager_->GetCurrentInputMethod().id());
 }
 
 TEST_F(InputMethodManagerImplTest,
        ChangeInputMethodBeforeComponentExtensionInitialization_TwoIME) {
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back(kNaclMozcUsId);
-  ids.push_back(kNaclMozcJpId);
+  ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
+  ids.push_back(ImeIdFromEngineId(kNaclMozcJpId));
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  manager_->ChangeInputMethod(kNaclMozcUsId);
-  manager_->ChangeInputMethod(kNaclMozcJpId);
+  manager_->ChangeInputMethod(ImeIdFromEngineId(kNaclMozcUsId));
+  manager_->ChangeInputMethod(ImeIdFromEngineId(kNaclMozcJpId));
 
   InitComponentExtension();
-  EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(ImeIdFromEngineId(kNaclMozcJpId),
+            manager_->GetCurrentInputMethod().id());
 }
 
 TEST_F(InputMethodManagerImplTest,
@@ -1338,55 +1351,24 @@ TEST_F(InputMethodManagerImplTest,
   EXPECT_EQ(ext_id2, manager_->GetCurrentInputMethod().id());
 }
 
-TEST_F(InputMethodManagerImplTest, MigrateInputMethodTest_1) {
-  extension_ime_util::ScopedUseExtensionKeyboardFlagForTesting
-      scoped_flag(true);
-
+TEST_F(InputMethodManagerImplTest, MigrateInputMethodTest) {
   std::vector<std::string> input_method_ids;
   input_method_ids.push_back("xkb:us::eng");
   input_method_ids.push_back("xkb:fr::fra");
-  input_method_ids.push_back(
-      std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
+  input_method_ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
   input_method_ids.push_back("xkb:fr::fra");
-  input_method_ids.push_back(
-      std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
+  input_method_ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
   input_method_ids.push_back("_comp_ime_asdf_pinyin");
-  input_method_ids.push_back(kNaclMozcUsId);
+  input_method_ids.push_back(ImeIdFromEngineId(kPinyinImeId));
 
   manager_->MigrateInputMethods(&input_method_ids);
 
   ASSERT_EQ(4U, input_method_ids.size());
 
-  EXPECT_EQ(std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng",
-            input_method_ids[0]);
-  EXPECT_EQ(std::string("_comp_ime_") + kXkbExtId + "xkb:fr::fra",
-            input_method_ids[1]);
-  EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
-  EXPECT_EQ("_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopnacl_mozc_us",
-            input_method_ids[3]);
-}
-
-TEST_F(InputMethodManagerImplTest, MigrateInputMethodTest_2) {
-  extension_ime_util::ScopedUseExtensionKeyboardFlagForTesting
-      scoped_flag(false);
-
-  std::vector<std::string> input_method_ids;
-  input_method_ids.push_back("xkb:us::eng");
-  input_method_ids.push_back("xkb:fr::fra");
-  input_method_ids.push_back(
-      std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
-  input_method_ids.push_back("xkb:fr::fra");
-  input_method_ids.push_back(
-      std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
-  input_method_ids.push_back("_comp_ime_asdf_pinyin");
-
-  manager_->MigrateInputMethods(&input_method_ids);
-
-  ASSERT_EQ(3U, input_method_ids.size());
-
-  EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
-  EXPECT_EQ("xkb:fr::fra", input_method_ids[1]);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"), input_method_ids[0]);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:fr::fra"), input_method_ids[1]);
   EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
+  EXPECT_EQ(ImeIdFromEngineId("zh-t-i0-pinyin"), input_method_ids[3]);
 }
 
 }  // namespace input_method
diff --git a/chrome/browser/chromeos/input_method/input_method_util.cc b/chrome/browser/chromeos/input_method/input_method_util.cc
index 72ed8b4..ac42963 100644
--- a/chrome/browser/chromeos/input_method/input_method_util.cc
+++ b/chrome/browser/chromeos/input_method/input_method_util.cc
@@ -31,46 +31,26 @@ namespace {
 // 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.
@@ -86,28 +66,20 @@ const size_t kMappingFromIdToIndicatorTextLen =
 // "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 },
@@ -122,22 +94,14 @@ const size_t kMappingImeIdToMediumLenNameResourceIdLen =
 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.
@@ -477,8 +441,8 @@ base::string16 InputMethodUtil::GetInputMethodShortName(
   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;
     }
@@ -515,7 +479,8 @@ base::string16 InputMethodUtil::GetInputMethodMediumName(
   // 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);
@@ -624,7 +589,8 @@ void InputMethodUtil::GetFirstLoginInputMethodIds(
     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;
     }
   }
@@ -709,7 +675,7 @@ bool InputMethodUtil::MigrateInputMethods(
   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]);
@@ -822,15 +788,13 @@ void InputMethodUtil::ResetInputMethods(const InputMethodDescriptors& 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(),
@@ -848,7 +812,7 @@ InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
   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,
@@ -872,7 +836,7 @@ void InputMethodUtil::ReloadInternalMaps() {
   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();
 
diff --git a/chrome/browser/chromeos/input_method/input_method_util_unittest.cc b/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
index be5be9b..83452a5 100644
--- a/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
+++ b/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
@@ -27,16 +27,8 @@ namespace input_method {
 
 namespace {
 
-const char pinyin_ime_id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin";
-const char zhuyin_ime_id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-hant-t-i0-und";
-const char kKeyboardExtId[] =
-#if defined(OFFICIAL_BUILD)
-    "habcdindjejkmepknlhkkloncjcpcnbf";
-#else
-    "jhffeifommiaekmbkkjlpmilogcfdohp";
-#endif
+const char pinyin_ime_id[] = "zh-t-i0-pinyin";
+const char zhuyin_ime_id[] = "zh-hant-t-i0-und";
 
 class TestableInputMethodUtil : public InputMethodUtil {
  public:
@@ -71,7 +63,7 @@ class InputMethodUtilTest : public testing::Test {
     layouts.push_back("us");
     languages.push_back("zh-CN");
 
-    InputMethodDescriptor pinyin_ime(pinyin_ime_id,
+    InputMethodDescriptor pinyin_ime(Id(pinyin_ime_id),
                                      "Pinyin input for testing",
                                      "CN",
                                      layouts,
@@ -98,7 +90,7 @@ class InputMethodUtilTest : public testing::Test {
   }
 
   std::string Id(const std::string& id) {
-    return extension_ime_util::GetInputMethodIDByKeyboardLayout(id);
+    return extension_ime_util::GetInputMethodIDByEngineID(id);
   }
 
   InputMethodDescriptor GetDesc(const std::string& id,
@@ -131,14 +123,14 @@ class InputMethodUtilTest : public testing::Test {
 TEST_F(InputMethodUtilTest, GetInputMethodShortNameTest) {
   // Test normal cases. Two-letter language code should be returned.
   {
-    InputMethodDescriptor desc = GetDesc("m17n:fa:isiri",  // input method id
+    InputMethodDescriptor desc = GetDesc("vkd_fa",  // input method id
                                          "us",  // keyboard layout name
                                          "fa", // language name
                                          ""); // indicator
     EXPECT_EQ(ASCIIToUTF16("FA"), util_.GetInputMethodShortName(desc));
   }
   {
-    InputMethodDescriptor desc = GetDesc("mozc-hangul", "us", "ko", "");
+    InputMethodDescriptor desc = GetDesc("hangul_2set", "us", "ko", "");
     EXPECT_EQ(base::UTF8ToUTF16("\xed\x95\x9c"),
               util_.GetInputMethodShortName(desc));
   }
@@ -186,8 +178,7 @@ TEST_F(InputMethodUtilTest, GetInputMethodShortNameTest) {
               util_.GetInputMethodShortName(desc));
   }
   {
-    InputMethodDescriptor desc =
-        GetDesc(zhuyin_ime_id, "us", "zh-TW", "");
+    InputMethodDescriptor desc = GetDesc(zhuyin_ime_id, "us", "zh-TW", "");
     EXPECT_EQ(base::UTF8ToUTF16("\xE6\xB3\xA8"),
               util_.GetInputMethodShortName(desc));
   }
@@ -216,13 +207,8 @@ TEST_F(InputMethodUtilTest, GetInputMethodMediumNameTest) {
   {
     // input methods with medium name not equal to short name
     const char * input_method_id[] = {
-      "m17n:zh:cangjie",
-      "m17n:zh:quick",
       pinyin_ime_id,
       zhuyin_ime_id,
-      "mozc-hangul",
-      pinyin_ime_id,
-      pinyin_ime_id,
     };
     const int len = ARRAYSIZE_UNSAFE(input_method_id);
     for (int i=0; i<len; ++i) {
@@ -238,21 +224,6 @@ TEST_F(InputMethodUtilTest, GetInputMethodLongNameTest) {
   // For most languages input method or keyboard layout name is returned.
   // See below for exceptions.
   {
-    InputMethodDescriptor desc = GetDesc("m17n:fa:isiri", "us", "fa", "");
-    EXPECT_EQ(ASCIIToUTF16("Persian input method (ISIRI 2901 layout)"),
-              util_.GetInputMethodLongName(desc));
-  }
-  {
-    InputMethodDescriptor desc = GetDesc("mozc-hangul", "us", "ko", "");
-    EXPECT_EQ(ASCIIToUTF16("Korean input method"),
-              util_.GetInputMethodLongName(desc));
-  }
-  {
-    InputMethodDescriptor desc = GetDesc("m17n:vi:tcvn", "us", "vi", "");
-    EXPECT_EQ(ASCIIToUTF16("Vietnamese input method (TCVN6064)"),
-              util_.GetInputMethodLongName(desc));
-  }
-  {
     InputMethodDescriptor desc = GetDesc("xkb:jp::jpn", "jp", "ja", "");
     EXPECT_EQ(ASCIIToUTF16("Japanese"),
               util_.GetInputMethodLongName(desc));
@@ -270,14 +241,9 @@ TEST_F(InputMethodUtilTest, GetInputMethodLongNameTest) {
               util_.GetInputMethodLongName(desc));
   }
 
-  // For Arabic, Dutch, French, German and Hindi,
+  // For Dutch, French, German and Hindi,
   // "language - keyboard layout" pair is returned.
   {
-    InputMethodDescriptor desc = GetDesc("m17n:ar:kbd", "us", "ar", "");
-    EXPECT_EQ(ASCIIToUTF16("Arabic - Standard input method"),
-              util_.GetInputMethodLongName(desc));
-  }
-  {
     InputMethodDescriptor desc = GetDesc("xkb:be::nld", "be", "nl", "");
     EXPECT_EQ(ASCIIToUTF16("Dutch - Belgian"),
               util_.GetInputMethodLongName(desc));
@@ -302,11 +268,6 @@ TEST_F(InputMethodUtilTest, GetInputMethodLongNameTest) {
     EXPECT_EQ(ASCIIToUTF16("German - Belgian"),
               util_.GetInputMethodLongName(desc));
   }
-  {
-    InputMethodDescriptor desc = GetDesc("m17n:hi:itrans", "us", "hi", "");
-    EXPECT_EQ(ASCIIToUTF16("Hindi - Standard input method"),
-              util_.GetInputMethodLongName(desc));
-  }
 
   {
     InputMethodDescriptor desc = GetDesc("invalid-id", "us", "xx", "");
@@ -319,13 +280,13 @@ TEST_F(InputMethodUtilTest, GetInputMethodLongNameTest) {
 
 TEST_F(InputMethodUtilTest, TestIsValidInputMethodId) {
   EXPECT_TRUE(util_.IsValidInputMethodId(Id("xkb:us:colemak:eng")));
-  EXPECT_TRUE(util_.IsValidInputMethodId(pinyin_ime_id));
+  EXPECT_TRUE(util_.IsValidInputMethodId(Id(pinyin_ime_id)));
   EXPECT_FALSE(util_.IsValidInputMethodId("unsupported-input-method"));
 }
 
 TEST_F(InputMethodUtilTest, TestIsKeyboardLayout) {
   EXPECT_TRUE(InputMethodUtil::IsKeyboardLayout("xkb:us::eng"));
-  EXPECT_FALSE(InputMethodUtil::IsKeyboardLayout(pinyin_ime_id));
+  EXPECT_FALSE(InputMethodUtil::IsKeyboardLayout(Id(pinyin_ime_id)));
 }
 
 TEST_F(InputMethodUtilTest, TestGetKeyboardLayoutName) {
@@ -333,7 +294,7 @@ TEST_F(InputMethodUtilTest, TestGetKeyboardLayoutName) {
   EXPECT_EQ("", util_.GetKeyboardLayoutName("UNSUPPORTED_ID"));
 
   // Supported cases (samples).
-  EXPECT_EQ("us", util_.GetKeyboardLayoutName(pinyin_ime_id));
+  EXPECT_EQ("us", util_.GetKeyboardLayoutName(Id(pinyin_ime_id)));
   EXPECT_EQ("es", util_.GetKeyboardLayoutName(Id("xkb:es::spa")));
   EXPECT_EQ("es(cat)", util_.GetKeyboardLayoutName(Id("xkb:es:cat:cat")));
   EXPECT_EQ("gb(extd)", util_.GetKeyboardLayoutName(Id("xkb:gb:extd:eng")));
@@ -346,7 +307,7 @@ TEST_F(InputMethodUtilTest, TestGetKeyboardLayoutName) {
 
 TEST_F(InputMethodUtilTest, TestGetLanguageCodeFromInputMethodId) {
   // Make sure that the -CN is added properly.
-  EXPECT_EQ("zh-CN", util_.GetLanguageCodeFromInputMethodId(pinyin_ime_id));
+  EXPECT_EQ("zh-CN", util_.GetLanguageCodeFromInputMethodId(Id(pinyin_ime_id)));
 }
 
 TEST_F(InputMethodUtilTest, TestGetInputMethodDisplayNameFromId) {
@@ -359,9 +320,9 @@ TEST_F(InputMethodUtilTest, TestGetInputMethodDescriptorFromId) {
   EXPECT_EQ(NULL, util_.GetInputMethodDescriptorFromId("non_existent"));
 
   const InputMethodDescriptor* descriptor =
-      util_.GetInputMethodDescriptorFromId(pinyin_ime_id);
+      util_.GetInputMethodDescriptorFromId(Id(pinyin_ime_id));
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
-  EXPECT_EQ(pinyin_ime_id, descriptor->id());
+  EXPECT_EQ(Id(pinyin_ime_id), descriptor->id());
   EXPECT_EQ("us", descriptor->GetPreferredKeyboardLayout());
   // This used to be "zh" but now we have "zh-CN" in input_methods.h,
   // hence this should be zh-CN now.
@@ -420,7 +381,7 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Zh) {
   util_.GetFirstLoginInputMethodIds("zh-CN", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ(Id("xkb:us::eng"), input_method_ids[0]);
-  EXPECT_EQ(pinyin_ime_id, input_method_ids[1]);  // Pinyin for US keybaord.
+  EXPECT_EQ(Id(pinyin_ime_id), input_method_ids[1]);  // Pinyin for US keybaord.
 }
 
 // US keyboard + Russian UI = US keyboard + Russsian keyboard
@@ -444,7 +405,7 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_ZhTw) {
   util_.GetFirstLoginInputMethodIds("zh-TW", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ(Id("xkb:us::eng"), input_method_ids[0]);
-  EXPECT_EQ(zhuyin_ime_id, input_method_ids[1]);  // Chewing.
+  EXPECT_EQ(Id(zhuyin_ime_id), input_method_ids[1]);  // Chewing.
 }
 
 // US keyboard + Thai = US keyboard + kesmanee.
@@ -456,8 +417,7 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Th) {
   util_.GetFirstLoginInputMethodIds("th", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ(Id("xkb:us::eng"), input_method_ids[0]);
-  EXPECT_EQ(std::string("_comp_ime_") + kKeyboardExtId + "vkd_th",
-            input_method_ids[1]);  // Kesmanee.
+  EXPECT_EQ(Id("vkd_th"), input_method_ids[1]);  // Kesmanee.
 }
 
 // US keyboard + Vietnamese = US keyboard + TCVN6064.
@@ -469,15 +429,14 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Vi) {
   util_.GetFirstLoginInputMethodIds("vi", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ(Id("xkb:us::eng"), input_method_ids[0]);
-  EXPECT_EQ(std::string("_comp_ime_") + kKeyboardExtId + "vkd_vi_tcvn",
-            input_method_ids[1]);  // TCVN6064.
+  EXPECT_EQ(Id("vkd_vi_tcvn"), input_method_ids[1]);  // TCVN6064.
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageCodesFromInputMethodIds) {
   std::vector<std::string> input_method_ids;
   input_method_ids.push_back(Id("xkb:us::eng"));        // English US.
   input_method_ids.push_back(Id("xkb:us:dvorak:eng"));  // English US Dvorak.
-  input_method_ids.push_back(pinyin_ime_id);  // Pinyin
+  input_method_ids.push_back(Id(pinyin_ime_id));        // Pinyin
   input_method_ids.push_back(Id("xkb:fr::fra"));        // French France.
   std::vector<std::string> language_codes;
   util_.GetLanguageCodesFromInputMethodIds(input_method_ids, &language_codes);
diff --git a/chrome/browser/chromeos/input_method/mode_indicator_browsertest.cc b/chrome/browser/chromeos/input_method/mode_indicator_browsertest.cc
index b8bf3b4..e047731 100644
--- a/chrome/browser/chromeos/input_method/mode_indicator_browsertest.cc
+++ b/chrome/browser/chromeos/input_method/mode_indicator_browsertest.cc
@@ -133,7 +133,7 @@ IN_PROC_BROWSER_TEST_F(ModeIndicatorBrowserTest, Bounds) {
 
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(
-      extension_ime_util::GetInputMethodIDByKeyboardLayout("xkb:fr::fra"));
+      extension_ime_util::GetInputMethodIDByEngineID("xkb:fr::fra"));
 
   // Add keyboard layouts to enable the mode indicator.
   imm->EnableLoginLayouts("fr", keyboard_layouts);
@@ -201,7 +201,7 @@ IN_PROC_BROWSER_TEST_F(ModeIndicatorBrowserTest, NumOfWidgets) {
 
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(
-      extension_ime_util::GetInputMethodIDByKeyboardLayout("xkb:fr::fra"));
+      extension_ime_util::GetInputMethodIDByEngineID("xkb:fr::fra"));
 
   // Add keyboard layouts to enable the mode indicator.
   imm->EnableLoginLayouts("fr", keyboard_layouts);
diff --git a/chrome/browser/chromeos/login/oobe_localization_browsertest.cc b/chrome/browser/chromeos/login/oobe_localization_browsertest.cc
index c9007eb..f680218 100644
--- a/chrome/browser/chromeos/login/oobe_localization_browsertest.cc
+++ b/chrome/browser/chromeos/login/oobe_localization_browsertest.cc
@@ -223,14 +223,12 @@ std::string OobeLocalizationTest::DumpOptions(const char* select_id) {
 
 std::string TranslateXKB2Extension(const std::string& src) {
   std::string result(src);
-  if (!extension_ime_util::UseWrappedExtensionKeyboardLayouts())
-    return result;
   // Modifies the expected keyboard select control options for the new
   // extension based xkb id.
   size_t pos = 0;
   std::string repl_old = "xkb:";
   std::string repl_new =
-      extension_ime_util::GetInputMethodIDByKeyboardLayout("xkb:");
+      extension_ime_util::GetInputMethodIDByEngineID("xkb:");
   while ((pos = result.find(repl_old, pos)) != std::string::npos) {
     result.replace(pos, repl_old.length(), repl_new);
     pos += repl_new.length();
@@ -285,7 +283,7 @@ void OobeLocalizationTest::RunLocalizationTest(
 
   // Make sure we have a fallback keyboard.
   if (!VerifyOptionExists(kKeyboardSelect,
-                          extension_ime_util::GetInputMethodIDByKeyboardLayout(
+                          extension_ime_util::GetInputMethodIDByEngineID(
                               kUSLayout).c_str())) {
     LOG(ERROR) << "Actual value of " << kKeyboardSelect << ":\n"
                << DumpOptions(kKeyboardSelect);
diff --git a/chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc b/chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc
index 15939c5..e19d547 100644
--- a/chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc
+++ b/chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc
@@ -53,8 +53,6 @@ const char kJsApiNetworkOnLanguageChanged[] = "networkOnLanguageChanged";
 const char kJsApiNetworkOnInputMethodChanged[] = "networkOnInputMethodChanged";
 const char kJsApiNetworkOnTimezoneChanged[] = "networkOnTimezoneChanged";
 
-const char kUSLayout[] = "xkb:us::eng";
-
 const int kDerelectDetectionTimeoutSeconds = 8 * 60 * 60;  // 8 hours.
 const int kDerelectIdleTimeoutSeconds = 5 * 60;  // 5 minutes.
 const int kOobeTimerUpdateIntervalSeconds = 5 * 60;  // 5 minutes.
@@ -450,12 +448,8 @@ base::ListValue* NetworkScreenHandler::GetLanguageList() {
   ComponentExtensionIMEManager* comp_manager =
       manager->GetComponentExtensionIMEManager();
   input_method::InputMethodDescriptors descriptors;
-  if (extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
-    if (comp_manager->IsInitialized())
-      descriptors = comp_manager->GetXkbIMEAsInputMethodDescriptor();
-  } else {
-    descriptors = *(manager->GetSupportedInputMethods());
-  }
+  if (comp_manager->IsInitialized())
+    descriptors = comp_manager->GetXkbIMEAsInputMethodDescriptor();
   base::ListValue* languages_list =
       options::CrosLanguageOptionsHandler::GetUILanguageList(descriptors);
   for (size_t i = 0; i < languages_list->GetSize(); ++i) {
@@ -538,16 +532,14 @@ base::ListValue* NetworkScreenHandler::GetInputMethods() {
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   input_method::InputMethodUtil* util = manager->GetInputMethodUtil();
-  if (extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
-    ComponentExtensionIMEManager* comp_manager =
-        manager->GetComponentExtensionIMEManager();
-    if (!comp_manager->IsInitialized()) {
-      input_method::InputMethodDescriptor fallback =
-          util->GetFallbackInputMethodDescriptor();
-      input_methods_list->Append(
-          CreateInputMethodsEntry(fallback, fallback.id()));
-      return input_methods_list;
-    }
+  ComponentExtensionIMEManager* comp_manager =
+      manager->GetComponentExtensionIMEManager();
+  if (!comp_manager->IsInitialized()) {
+    input_method::InputMethodDescriptor fallback =
+        util->GetFallbackInputMethodDescriptor();
+    input_methods_list->Append(
+        CreateInputMethodsEntry(fallback, fallback.id()));
+    return input_methods_list;
   }
 
   const std::vector<std::string>& hardware_login_input_methods =
@@ -590,8 +582,8 @@ base::ListValue* NetworkScreenHandler::GetInputMethods() {
         CreateInputMethodsEntry((*input_methods)[i], current_input_method_id));
   }
   // "xkb:us::eng" should always be in the list of available layouts.
-  const std::string& us_keyboard_id =
-      extension_ime_util::GetInputMethodIDByKeyboardLayout(kUSLayout);
+  const std::string us_keyboard_id =
+      util->GetFallbackInputMethodDescriptor().id();
   if (input_methods_added.find(us_keyboard_id) == input_methods_added.end()) {
     const input_method::InputMethodDescriptor* us_eng_descriptor =
         util->GetInputMethodDescriptorFromId(us_keyboard_id);
diff --git a/chromeos/ime/extension_ime_util.cc b/chromeos/ime/extension_ime_util.cc
index 9a1ee88..474622d 100644
--- a/chromeos/ime/extension_ime_util.cc
+++ b/chromeos/ime/extension_ime_util.cc
@@ -7,26 +7,22 @@
 #include "base/strings/string_util.h"
 
 namespace chromeos {
+
 namespace {
+
 const char kExtensionIMEPrefix[] = "_ext_ime_";
 const int kExtensionIMEPrefixLength =
     sizeof(kExtensionIMEPrefix) / sizeof(kExtensionIMEPrefix[0]) - 1;
 const char kComponentExtensionIMEPrefix[] = "_comp_ime_";
-const char kPublicExtensionXkbIdPrefix[] =
-    "_comp_ime_fgoepimhcoialccpbmpnnblemnepkkao";
-const char kInternalExtensionXkbIdPrefix[] =
-    "_comp_ime_jkghodnilhceideoidjikpgommlajknk";
-
 const int kComponentExtensionIMEPrefixLength =
     sizeof(kComponentExtensionIMEPrefix) /
         sizeof(kComponentExtensionIMEPrefix[0]) - 1;
 const int kExtensionIdLength = 32;
-// Hard coded to true. If the wrapped extension keyboards misbehaves,
-// we can easily change this to false to switch back to legacy xkb keyboards.
-bool g_use_wrapped_extension_keyboard_layouts = true;
+
 }  // namespace
 
 namespace extension_ime_util {
+
 std::string GetInputMethodID(const std::string& extension_id,
                              const std::string& engine_id) {
   DCHECK(!extension_id.empty());
@@ -58,25 +54,36 @@ std::string GetExtensionIDFromInputMethodID(
   return "";
 }
 
-std::string GetInputMethodIDByKeyboardLayout(
-    const std::string& keyboard_layout_id) {
-  const char* kExtensionXkbIdPrefix =
-#if defined(OFFICIAL_BUILD)
-      kInternalExtensionXkbIdPrefix;
-#else
-      kPublicExtensionXkbIdPrefix;
-#endif
-  bool migrate = UseWrappedExtensionKeyboardLayouts();
-  if (IsKeyboardLayoutExtension(keyboard_layout_id)) {
-    std::string id = keyboard_layout_id.substr(
-        arraysize(kPublicExtensionXkbIdPrefix) - 1);
-    if (migrate)
-      return kExtensionXkbIdPrefix + id;
-    return id;
+std::string GetInputMethodIDByEngineID(const std::string& engine_id) {
+  if (StartsWithASCII(engine_id, kComponentExtensionIMEPrefix, true) ||
+      StartsWithASCII(engine_id, kExtensionIMEPrefix, true)) {
+    return engine_id;
+  }
+  if (StartsWithASCII(engine_id, "xkb:", true))
+    return GetComponentInputMethodID(kXkbExtensionId, engine_id);
+  if (StartsWithASCII(engine_id, "vkd_", true))
+    return GetComponentInputMethodID(kM17nExtensionId, engine_id);
+  if (StartsWithASCII(engine_id, "nacl_mozc_", true))
+    return GetComponentInputMethodID(kMozcExtensionId, engine_id);
+  if (StartsWithASCII(engine_id, "hangul_", true))
+    return GetComponentInputMethodID(kHangulExtensionId, engine_id);
+
+  if (StartsWithASCII(engine_id, "zh-", true) &&
+      engine_id.find("pinyin") != std::string::npos) {
+    return GetComponentInputMethodID(kChinesePinyinExtensionId, engine_id);
+  }
+  if (StartsWithASCII(engine_id, "zh-", true) &&
+      engine_id.find("zhuyin") != std::string::npos) {
+    return GetComponentInputMethodID(kChineseZhuyinExtensionId, engine_id);
+  }
+  if (StartsWithASCII(engine_id, "zh-", true) &&
+      engine_id.find("cangjie") != std::string::npos) {
+    return GetComponentInputMethodID(kChineseCangjieExtensionId, engine_id);
   }
-  if (migrate && StartsWithASCII(keyboard_layout_id, "xkb:", true))
-    return kExtensionXkbIdPrefix + keyboard_layout_id;
-  return keyboard_layout_id;
+  if (engine_id.find("-t-i0-") != std::string::npos)
+    return GetComponentInputMethodID(kT13nExtensionId, engine_id);
+
+  return engine_id;
 }
 
 bool IsExtensionIME(const std::string& input_method_id) {
@@ -99,12 +106,8 @@ bool IsMemberOfExtension(const std::string& input_method_id,
 }
 
 bool IsKeyboardLayoutExtension(const std::string& input_method_id) {
-  return StartsWithASCII(input_method_id, kPublicExtensionXkbIdPrefix, true) ||
-      StartsWithASCII(input_method_id, kInternalExtensionXkbIdPrefix, true);
-}
-
-bool UseWrappedExtensionKeyboardLayouts() {
-  return g_use_wrapped_extension_keyboard_layouts;
+  std::string prefix = kComponentExtensionIMEPrefix;
+  return StartsWithASCII(input_method_id, prefix + kXkbExtensionId, true);
 }
 
 std::string MaybeGetLegacyXkbId(const std::string& input_method_id) {
@@ -116,14 +119,5 @@ std::string MaybeGetLegacyXkbId(const std::string& input_method_id) {
   return input_method_id;
 }
 
-ScopedUseExtensionKeyboardFlagForTesting::
-    ScopedUseExtensionKeyboardFlagForTesting(bool new_flag)
-  : auto_reset_(&g_use_wrapped_extension_keyboard_layouts, new_flag) {
-}
-
-ScopedUseExtensionKeyboardFlagForTesting::
-    ~ScopedUseExtensionKeyboardFlagForTesting() {
-}
-
 }  // namespace extension_ime_util
 }  // namespace chromeos
diff --git a/chromeos/ime/extension_ime_util.h b/chromeos/ime/extension_ime_util.h
index e663229..2bfc42b 100644
--- a/chromeos/ime/extension_ime_util.h
+++ b/chromeos/ime/extension_ime_util.h
@@ -15,6 +15,26 @@ namespace chromeos {
 // Extension IME related utilities.
 namespace extension_ime_util {
 
+#if defined(OFFICIAL_BUILD)
+const char kXkbExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
+const char kM17nExtensionId[] = "habcdindjejkmepknlhkkloncjcpcnbf";
+const char kHangulExtensionId[] = "bdgdidmhaijohebebipajioienkglgfo";
+const char kMozcExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+const char kT13nExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+const char kChinesePinyinExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+const char kChineseZhuyinExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+const char kChineseCangjieExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+#else
+const char kXkbExtensionId[] = "fgoepimhcoialccpbmpnnblemnepkkao";
+const char kM17nExtensionId[] = "jhffeifommiaekmbkkjlpmilogcfdohp";
+const char kHangulExtensionId[] = "bdgdidmhaijohebebipajioienkglgfo";
+const char kMozcExtensionId[] = "bbaiamgfapehflhememkfglaehiobjnk";
+const char kT13nExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
+const char kChinesePinyinExtensionId[] = "cpgalbafkoofkjmaeonnfijgpfennjjn";
+const char kChineseZhuyinExtensionId[] = "ekbifjdfhkmdeeajnolmgdlmkllopefi";
+const char kChineseCangjieExtensionId[] = "aeebooiibjahgpgmhkeocbeekccfknbj";
+#endif
+
 // Returns InputMethodID for |engine_id| in |extension_id| of extension IME.
 // This function does not check |extension_id| is installed extension IME nor
 // |engine_id| is really a member of |extension_id|.
@@ -33,9 +53,12 @@ std::string CHROMEOS_EXPORT GetComponentInputMethodID(
 std::string CHROMEOS_EXPORT GetExtensionIDFromInputMethodID(
     const std::string& input_method_id);
 
-// Returns InputMethodID from keyboard layout (xkb) id (e.g. xkb:fr:fra).
-std::string CHROMEOS_EXPORT GetInputMethodIDByKeyboardLayout(
-    const std::string& keyboard_layout_id);
+// Returns InputMethodID from engine id (e.g. xkb:fr:fra), or returns itself if
+// the |engine_id| is not a known engine id.
+// The caller must make sure the |engine_id| is from system input methods
+// instead of 3rd party input methods.
+std::string CHROMEOS_EXPORT GetInputMethodIDByEngineID(
+    const std::string& engine_id);
 
 // Returns true if |input_method_id| is extension IME ID. This function does not
 // check |input_method_id| is installed extension IME.
@@ -58,27 +81,12 @@ bool CHROMEOS_EXPORT IsMemberOfExtension(const std::string& input_method_id,
 bool CHROMEOS_EXPORT IsKeyboardLayoutExtension(
     const std::string& input_method_id);
 
-// Returns true to use the wrapped extension keyboards instead of the legacy
-// xkb keyboards, returns false otherwise.
-bool CHROMEOS_EXPORT UseWrappedExtensionKeyboardLayouts();
-
 // Gets legacy xkb id (e.g. xkb:us::eng) from the new extension based xkb id
 // (e.g. _comp_ime_...xkb:us::eng). If the given id is not prefixed with
 // 'xkb:', just return the same as the given id.
 std::string CHROMEOS_EXPORT MaybeGetLegacyXkbId(
     const std::string& input_method_id);
 
-// The scoped class to temporarily set the flag to use extension based xkb
-// keyboards for testing.
-class CHROMEOS_EXPORT ScopedUseExtensionKeyboardFlagForTesting {
- public:
-  explicit ScopedUseExtensionKeyboardFlagForTesting(bool new_flag);
-  ~ScopedUseExtensionKeyboardFlagForTesting();
-
- private:
-  base::AutoReset<bool> auto_reset_;
-};
-
 }  // namespace extension_ime_util
 
 }  // namespace chromeos