projects / platform / framework / web / crosswalk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Upstream version 9.37.195.0
[platform/framework/web/crosswalk.git] / src / chrome / browser / chromeos / input_method / input_method_manager_impl_unittest.cc
diff --git a/src/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc b/src/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
index 3f3f212..551353e 100644 (file)
--- a/src/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
+++ b/src/chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc
@@ -15,16 +15,22 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
 #include "chrome/browser/chromeos/input_method/mock_candidate_window_controller.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_engine.h"
+#include "chrome/test/base/browser_with_test_window_test.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
+#include "chromeos/ime/fake_ime_keyboard.h"
 #include "chromeos/ime/fake_input_method_delegate.h"
-#include "chromeos/ime/fake_xkeyboard.h"
 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/ime/chromeos/mock_ime_engine_handler.h"
+#include "ui/base/ime/input_method_initializer.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace chromeos {
@@ -32,22 +38,11 @@ namespace chromeos {
 namespace input_method {
 namespace {
 
-const char kNaclMozcUsId[] =
-    "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us";
-const char kNaclMozcJpId[] =
-    "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp";
-const char kExt2Engine1Id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine1_engine_id";
-const char kExt2Engine2Id[] =
-    "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine2_engine_id";
-const char kPinyinImeId[] =
-    "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin";
-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,
@@ -59,20 +54,78 @@ 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 testing::Test {
+class TestObserver : public InputMethodManager::Observer,
+                     public ash::ime::InputMethodMenuManager::Observer {
+ public:
+  TestObserver()
+      : input_method_changed_count_(0),
+        input_method_menu_item_changed_count_(0),
+        last_show_message_(false) {
+  }
+  virtual ~TestObserver() {}
+
+  virtual void InputMethodChanged(InputMethodManager* manager,
+                                  bool show_message) OVERRIDE {
+    ++input_method_changed_count_;
+    last_show_message_ = show_message;
+  }
+  virtual void InputMethodMenuItemChanged(
+      ash::ime::InputMethodMenuManager* manager) OVERRIDE {
+    ++input_method_menu_item_changed_count_;
+  }
+
+  int input_method_changed_count_;
+  int input_method_menu_item_changed_count_;
+  bool last_show_message_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestObserver);
+};
+
+class TestCandidateWindowObserver
+    : public InputMethodManager::CandidateWindowObserver {
+ public:
+  TestCandidateWindowObserver()
+      : candidate_window_opened_count_(0),
+        candidate_window_closed_count_(0) {
+  }
+
+  virtual ~TestCandidateWindowObserver() {}
+
+  virtual void CandidateWindowOpened(InputMethodManager* manager) OVERRIDE {
+    ++candidate_window_opened_count_;
+  }
+  virtual void CandidateWindowClosed(InputMethodManager* manager) OVERRIDE {
+    ++candidate_window_closed_count_;
+  }
+
+  int candidate_window_opened_count_;
+  int candidate_window_closed_count_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestCandidateWindowObserver);
+};
+}  // namespace
+
+class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
  public:
   InputMethodManagerImplTest()
       : delegate_(NULL),
         candidate_window_controller_(NULL),
-        xkeyboard_(NULL) {
+        keyboard_(NULL) {
   }
   virtual ~InputMethodManagerImplTest() {}
 
   virtual void SetUp() OVERRIDE {
+    profile_manager_.reset(new TestingProfileManager(GetBrowserProcess()));
+    ASSERT_TRUE(profile_manager_->SetUp());
+
+    ui::InitializeInputMethodForTesting();
+
     delegate_ = new FakeInputMethodDelegate();
     manager_.reset(new InputMethodManagerImpl(
         scoped_ptr<InputMethodDelegate>(delegate_)));
@@ -80,18 +133,64 @@ class InputMethodManagerImplTest :  public testing::Test {
     candidate_window_controller_ = new MockCandidateWindowController;
     manager_->SetCandidateWindowControllerForTesting(
         candidate_window_controller_);
-    xkeyboard_ = new FakeXKeyboard;
-    manager_->SetXKeyboardForTesting(xkeyboard_);
-    mock_engine_handler_.reset(new MockIMEEngineHandler());
+    keyboard_ = new FakeImeKeyboard;
+    manager_->SetImeKeyboardForTesting(keyboard_);
+    mock_engine_handler_.reset(
+        new MockInputMethodEngine(InputMethodDescriptor()));
     IMEBridge::Initialize();
     IMEBridge::Get()->SetCurrentEngineHandler(mock_engine_handler_.get());
 
     menu_manager_ = ash::ime::InputMethodMenuManager::GetInstance();
 
+    InitImeList();
+
+    BrowserWithTestWindowTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    BrowserWithTestWindowTest::TearDown();
+
+    ui::ShutdownInputMethodForTesting();
+
+    delegate_ = NULL;
+    candidate_window_controller_ = NULL;
+    keyboard_ = NULL;
+    manager_.reset();
+
+    profile_manager_.reset();
+  }
+
+ protected:
+  Profile* GetProfile() { return manager_->GetProfile(); }
+  // Helper function to initialize component extension stuff for testing.
+  void InitComponentExtension() {
+    mock_delegate_ = new MockComponentExtIMEManagerDelegate();
+    mock_delegate_->set_ime_list(ime_list_);
+    scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate_);
+
+    // Note, for production, these SetEngineHandler are called when
+    // IMEEngineHandlerInterface is initialized via
+    // InitializeComponentextension.
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kNaclMozcUsId),
+                                      mock_engine_handler_.get());
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kNaclMozcJpId),
+                                      mock_engine_handler_.get());
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kExt2Engine1Id),
+                                      mock_engine_handler_.get());
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kExt2Engine2Id),
+                                      mock_engine_handler_.get());
+    manager_->InitializeComponentExtensionForTesting(delegate.Pass());
+  }
+
+  void InitImeList() {
     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");
 
@@ -168,7 +267,7 @@ class InputMethodManagerImplTest :  public testing::Test {
     ime_list_.push_back(ext_xkb);
 
     ComponentExtensionIME ext1;
-    ext1.id = "fpfbhcjppmaeaijcidgiibchfbnhbelj";
+    ext1.id = extension_ime_util::kMozcExtensionId;
     ext1.description = "ext1_description";
     ext1.path = base::FilePath("ext1_file_path");
 
@@ -189,19 +288,19 @@ class InputMethodManagerImplTest :  public testing::Test {
     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)");
@@ -210,42 +309,16 @@ class InputMethodManagerImplTest :  public testing::Test {
     ime_list_.push_back(ext2);
   }
 
-  virtual void TearDown() OVERRIDE {
-    delegate_ = NULL;
-    candidate_window_controller_ = NULL;
-    xkeyboard_ = NULL;
-    manager_.reset();
-
-    IMEBridge::Get()->SetCurrentEngineHandler(NULL);
-    IMEBridge::Shutdown();
-  }
-
- protected:
-  // Helper function to initialize component extension stuff for testing.
-  void InitComponentExtension() {
-    mock_delegate_ = new MockComponentExtIMEManagerDelegate();
-    mock_delegate_->set_ime_list(ime_list_);
-    scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate_);
-    // Note, for production, these SetEngineHandler are called when
-    // IMEEngineHandlerInterface is initialized via
-    // InitializeComponentextension.
-    IMEBridge::Get()->SetEngineHandler(kNaclMozcUsId,
-                                        mock_engine_handler_.get());
-    IMEBridge::Get()->SetEngineHandler(kNaclMozcJpId,
-                                        mock_engine_handler_.get());
-    IMEBridge::Get()->SetEngineHandler(kExt2Engine1Id,
-                                        mock_engine_handler_.get());
-    IMEBridge::Get()->SetEngineHandler(kExt2Engine2Id,
-                                        mock_engine_handler_.get());
-    manager_->InitializeComponentExtensionForTesting(delegate.Pass());
+  TestingBrowserProcess* GetBrowserProcess() {
+    return TestingBrowserProcess::GetGlobal();
   }
 
+  scoped_ptr<TestingProfileManager> profile_manager_;
   scoped_ptr<InputMethodManagerImpl> manager_;
   FakeInputMethodDelegate* delegate_;
   MockCandidateWindowController* candidate_window_controller_;
-  scoped_ptr<MockIMEEngineHandler> mock_engine_handler_;
-  FakeXKeyboard* xkeyboard_;
-  base::MessageLoop message_loop_;
+  scoped_ptr<MockInputMethodEngine> mock_engine_handler_;
+  FakeImeKeyboard* keyboard_;
   MockComponentExtIMEManagerDelegate* mock_delegate_;
   std::vector<ComponentExtensionIME> ime_list_;
   ash::ime::InputMethodMenuManager* menu_manager_;
@@ -254,61 +327,9 @@ class InputMethodManagerImplTest :  public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 };
 
-class TestObserver : public InputMethodManager::Observer,
-                     public ash::ime::InputMethodMenuManager::Observer{
- public:
-  TestObserver()
-      : input_method_changed_count_(0),
-        input_method_menu_item_changed_count_(0),
-        last_show_message_(false) {
-  }
-  virtual ~TestObserver() {}
-
-  virtual void InputMethodChanged(InputMethodManager* manager,
-                                  bool show_message) OVERRIDE {
-    ++input_method_changed_count_;
-    last_show_message_ = show_message;
-  }
-  virtual void InputMethodMenuItemChanged(
-      ash::ime::InputMethodMenuManager* manager) OVERRIDE {
-    ++input_method_menu_item_changed_count_;
-  }
-
-  int input_method_changed_count_;
-  int input_method_menu_item_changed_count_;
-  bool last_show_message_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestObserver);
-};
-
-class TestCandidateWindowObserver
-    : public InputMethodManager::CandidateWindowObserver {
- public:
-  TestCandidateWindowObserver()
-      : candidate_window_opened_count_(0),
-        candidate_window_closed_count_(0) {
-  }
-  virtual ~TestCandidateWindowObserver() {}
-
-  virtual void CandidateWindowOpened(InputMethodManager* manager) OVERRIDE {
-    ++candidate_window_opened_count_;
-  }
-  virtual void CandidateWindowClosed(InputMethodManager* manager) OVERRIDE {
-    ++candidate_window_closed_count_;
-  }
-
-  int candidate_window_opened_count_;
-  int candidate_window_closed_count_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestCandidateWindowObserver);
-};
-}  // namespace
-
-TEST_F(InputMethodManagerImplTest, TestGetXKeyboard) {
-  EXPECT_TRUE(manager_->GetXKeyboard());
-  EXPECT_EQ(xkeyboard_, manager_->GetXKeyboard());
+TEST_F(InputMethodManagerImplTest, TestGetImeKeyboard) {
+  EXPECT_TRUE(manager_->GetImeKeyboard());
+  EXPECT_EQ(keyboard_, manager_->GetImeKeyboard());
 }
 
 TEST_F(InputMethodManagerImplTest, TestCandidateWindowObserver) {
@@ -342,11 +363,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
@@ -365,25 +386,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));
 }
 
@@ -405,12 +422,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) {
@@ -439,7 +456,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());
 }
 
@@ -479,10 +496,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));
 }
 
@@ -493,23 +510,23 @@ 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("us(dvorak)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
@@ -520,27 +537,27 @@ 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("us", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  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", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
@@ -551,23 +568,23 @@ 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("us(dvorak)", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme2) {
@@ -577,20 +594,20 @@ 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("us(dvorak)", xkeyboard_->last_layout_);
+  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", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
@@ -600,12 +617,12 @@ 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("us", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
@@ -632,36 +649,36 @@ 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("us", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Switch back to Qwerty.
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
@@ -673,37 +690,37 @@ 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("us(dvorak)", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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", xkeyboard_->last_layout_);
+  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("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[1]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
@@ -713,33 +730,33 @@ 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, xkeyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ(1, keyboard_->set_current_keyboard_layout_by_name_count_);
   // See input_methods.txt for an expected XKB layout name.
-  EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(2, xkeyboard_->set_current_keyboard_layout_by_name_count_);
-  EXPECT_EQ("us(colemak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(2, keyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(3, xkeyboard_->set_current_keyboard_layout_by_name_count_);
-  EXPECT_EQ("jp", xkeyboard_->last_layout_);
+  EXPECT_EQ(3, keyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ("jp", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(4, xkeyboard_->set_current_keyboard_layout_by_name_count_);
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ(4, keyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
-  EXPECT_EQ(5, xkeyboard_->set_current_keyboard_layout_by_name_count_);
-  EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(5, keyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
-  EXPECT_EQ(6, xkeyboard_->set_current_keyboard_layout_by_name_count_);
-  EXPECT_EQ("us(colemak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(6, keyboard_->set_current_keyboard_layout_by_name_count_);
+  EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestActivateInputMethodMenuItem) {
@@ -763,12 +780,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(
@@ -789,8 +806,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());
@@ -806,7 +823,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());
 
@@ -825,35 +842,38 @@ 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("us", xkeyboard_->last_layout_);
+  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("us(intl)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"),
+            manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
@@ -869,51 +889,57 @@ 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("us", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  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("us(intl)", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  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("us(intl)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  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("us(intl)", xkeyboard_->last_layout_);
+  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)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
@@ -930,7 +956,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());
 
@@ -943,16 +969,16 @@ 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());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Henkan, Muhenkan, ZenkakuHankaku should be ignored when no Japanese IMEs
   // and keyboards are enabled.
@@ -960,19 +986,19 @@ TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithUsLayouts) {
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
   EXPECT_FALSE(observer.last_show_message_);
   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_FALSE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_FALSE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   EXPECT_FALSE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
@@ -987,80 +1013,96 @@ 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("us", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("us", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("jp", keyboard_->last_layout_);
 }
 
 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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  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("jp", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId("xkb:jp::jpn"),
+            manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("jp", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
@@ -1069,13 +1111,12 @@ 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("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // Add two Extension IMEs.
   std::vector<std::string> layouts;
@@ -1094,7 +1135,7 @@ TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
                                           GURL(),
                                           GURL());
   MockInputMethodEngine engine(descriptor1);
-  manager_->AddInputMethodExtension(ext1_id, &engine);
+  manager_->AddInputMethodExtension(GetProfile(), ext1_id, &engine);
 
   // Extension IMEs are not enabled by default.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
@@ -1123,7 +1164,7 @@ TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
                                           GURL(),
                                           GURL());
   MockInputMethodEngine engine2(descriptor2);
-  manager_->AddInputMethodExtension(ext2_id, &engine2);
+  manager_->AddInputMethodExtension(GetProfile(), ext2_id, &engine2);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 
   extension_ime_ids.push_back(ext2_id);
@@ -1139,9 +1180,9 @@ TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
   }
 
   // Remove them.
-  manager_->RemoveInputMethodExtension(ext1_id);
+  manager_->RemoveInputMethodExtension(GetProfile(), ext1_id);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  manager_->RemoveInputMethodExtension(ext2_id);
+  manager_->RemoveInputMethodExtension(GetProfile(), ext2_id);
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 }
 
@@ -1151,12 +1192,12 @@ 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("us", xkeyboard_->last_layout_);
+  EXPECT_EQ(ImeIdFromEngineId(ids[0]), manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Add an Extension IME.
   std::vector<std::string> layouts;
@@ -1175,7 +1216,7 @@ TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
                                          GURL(),
                                          GURL());
   MockInputMethodEngine engine(descriptor);
-  manager_->AddInputMethodExtension(ext_id, &engine);
+  manager_->AddInputMethodExtension(GetProfile(), ext_id, &engine);
 
   // Extension IME is not enabled by default.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
@@ -1190,20 +1231,20 @@ TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(3, observer.input_method_changed_count_);
   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 
   // 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", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
 
   // Unlock the screen.
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
   {
     // This is for crosbug.com/27052.
     scoped_ptr<InputMethodDescriptors> methods(
@@ -1219,28 +1260,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,
@@ -1314,55 +1357,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(kPinyinImeId);
+  input_method_ids.push_back(ImeIdFromEngineId(kPinyinImeId));
 
-  manager_->MigrateXkbInputMethods(&input_method_ids);
+  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_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin",
-            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_->MigrateXkbInputMethods(&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
Domain: Web Framework / Uncategorized;