chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/input_method/input_method_manager_impl.h"
   6
   7 #include <algorithm>
   8
   9 #include "ash/ime/input_method_menu_item.h"
  10 #include "ash/ime/input_method_menu_manager.h"
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/logging.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/run_loop.h"
  19 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
  20 #include "chrome/browser/chromeos/input_method/mock_candidate_window_controller.h"
  21 #include "chrome/browser/chromeos/input_method/mock_input_method_engine.h"
  22 #include "chrome/test/base/browser_with_test_window_test.h"
  23 #include "chrome/test/base/testing_browser_process.h"
  24 #include "chrome/test/base/testing_profile.h"
  25 #include "chrome/test/base/testing_profile_manager.h"
  26 #include "chromeos/ime/extension_ime_util.h"
  27 #include "chromeos/ime/fake_ime_keyboard.h"
  28 #include "chromeos/ime/fake_input_method_delegate.h"
  29 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31 #include "ui/base/accelerators/accelerator.h"
  32 #include "ui/base/ime/chromeos/mock_ime_engine_handler.h"
  33 #include "ui/base/ime/input_method_initializer.h"
  34 #include "ui/events/keycodes/keyboard_codes.h"
  35
  36 namespace chromeos {
  37
  38 namespace input_method {
  39 namespace {
  40
  41 const char kNaclMozcUsId[] =
  42     "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us";
  43 const char kNaclMozcJpId[] =
  44     "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp";
  45 const char kExt2Engine1Id[] =
  46     "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine1_engine_id";
  47 const char kExt2Engine2Id[] =
  48     "_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopext2_engine2_engine_id";
  49 const char kPinyinImeId[] =
  50     "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin";
  51 const char kXkbExtId[] =
  52 #if defined(OFFICIAL_BUILD)
  53     "jkghodnilhceideoidjikpgommlajknk";
  54 #else
  55     "fgoepimhcoialccpbmpnnblemnepkkao";
  56 #endif
  57
  58 // Returns true if |descriptors| contain |target|.
  59 bool Contain(const InputMethodDescriptors& descriptors,
  60              const InputMethodDescriptor& target) {
  61   for (size_t i = 0; i < descriptors.size(); ++i) {
  62     if (descriptors[i].id() == target.id())
  63       return true;
  64   }
  65   return false;
  66 }
  67
  68 std::string XkbId(const std::string& id) {
  69   return extension_ime_util::GetInputMethodIDByKeyboardLayout(id);
  70 }
  71
  72 class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
  73  public:
  74   InputMethodManagerImplTest()
  75       : delegate_(NULL),
  76         candidate_window_controller_(NULL),
  77         keyboard_(NULL) {
  78   }
  79   virtual ~InputMethodManagerImplTest() {}
  80
  81   virtual void SetUp() OVERRIDE {
  82     profile_manager_.reset(new TestingProfileManager(GetBrowserProcess()));
  83     ASSERT_TRUE(profile_manager_->SetUp());
  84
  85     ui::InitializeInputMethodForTesting();
  86
  87     delegate_ = new FakeInputMethodDelegate();
  88     manager_.reset(new InputMethodManagerImpl(
  89         scoped_ptr<InputMethodDelegate>(delegate_)));
  90     manager_->GetInputMethodUtil()->UpdateHardwareLayoutCache();
  91     candidate_window_controller_ = new MockCandidateWindowController;
  92     manager_->SetCandidateWindowControllerForTesting(
  93         candidate_window_controller_);
  94     keyboard_ = new FakeImeKeyboard;
  95     manager_->SetImeKeyboardForTesting(keyboard_);
  96     mock_engine_handler_.reset(
  97         new MockInputMethodEngine(InputMethodDescriptor()));
  98     IMEBridge::Initialize();
  99     IMEBridge::Get()->SetCurrentEngineHandler(mock_engine_handler_.get());
 100
 101     menu_manager_ = ash::ime::InputMethodMenuManager::GetInstance();
 102
 103     InitImeList();
 104
 105     BrowserWithTestWindowTest::SetUp();
 106   }
 107
 108   virtual void TearDown() OVERRIDE {
 109     BrowserWithTestWindowTest::TearDown();
 110
 111     ui::ShutdownInputMethodForTesting();
 112
 113     delegate_ = NULL;
 114     candidate_window_controller_ = NULL;
 115     keyboard_ = NULL;
 116     manager_.reset();
 117
 118     profile_manager_.reset();
 119   }
 120
 121  protected:
 122   // Helper function to initialize component extension stuff for testing.
 123   void InitComponentExtension() {
 124     mock_delegate_ = new MockComponentExtIMEManagerDelegate();
 125     mock_delegate_->set_ime_list(ime_list_);
 126     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate_);
 127
 128     // Note, for production, these SetEngineHandler are called when
 129     // IMEEngineHandlerInterface is initialized via
 130     // InitializeComponentextension.
 131     manager_->AddInputMethodExtension(kNaclMozcUsId,
 132                                       mock_engine_handler_.get());
 133     manager_->AddInputMethodExtension(kNaclMozcJpId,
 134                                       mock_engine_handler_.get());
 135     manager_->AddInputMethodExtension(kExt2Engine1Id,
 136                                       mock_engine_handler_.get());
 137     manager_->AddInputMethodExtension(kExt2Engine2Id,
 138                                       mock_engine_handler_.get());
 139     manager_->InitializeComponentExtensionForTesting(delegate.Pass());
 140   }
 141
 142   void InitImeList() {
 143     ime_list_.clear();
 144
 145     ComponentExtensionIME ext_xkb;
 146     ext_xkb.id = kXkbExtId;
 147     ext_xkb.description = "ext_xkb_description";
 148     ext_xkb.path = base::FilePath("ext_xkb_file_path");
 149
 150     ComponentExtensionEngine ext_xkb_engine_us;
 151     ext_xkb_engine_us.engine_id = "xkb:us::eng";
 152     ext_xkb_engine_us.display_name = "xkb:us::eng";
 153     ext_xkb_engine_us.language_codes.push_back("en-US");
 154     ext_xkb_engine_us.layouts.push_back("us");
 155     ext_xkb.engines.push_back(ext_xkb_engine_us);
 156
 157     ComponentExtensionEngine ext_xkb_engine_intl;
 158     ext_xkb_engine_intl.engine_id = "xkb:us:intl:eng";
 159     ext_xkb_engine_intl.display_name = "xkb:us:intl:eng";
 160     ext_xkb_engine_intl.language_codes.push_back("en-US");
 161     ext_xkb_engine_intl.layouts.push_back("us(intl)");
 162     ext_xkb.engines.push_back(ext_xkb_engine_intl);
 163
 164     ComponentExtensionEngine ext_xkb_engine_altgr_intl;
 165     ext_xkb_engine_altgr_intl.engine_id = "xkb:us:altgr-intl:eng";
 166     ext_xkb_engine_altgr_intl.display_name = "xkb:us:altgr-intl:eng";
 167     ext_xkb_engine_altgr_intl.language_codes.push_back("en-US");
 168     ext_xkb_engine_altgr_intl.layouts.push_back("us(altgr-intl)");
 169     ext_xkb.engines.push_back(ext_xkb_engine_altgr_intl);
 170
 171     ComponentExtensionEngine ext_xkb_engine_dvorak;
 172     ext_xkb_engine_dvorak.engine_id = "xkb:us:dvorak:eng";
 173     ext_xkb_engine_dvorak.display_name = "xkb:us:dvorak:eng";
 174     ext_xkb_engine_dvorak.language_codes.push_back("en-US");
 175     ext_xkb_engine_dvorak.layouts.push_back("us(dvorak)");
 176     ext_xkb.engines.push_back(ext_xkb_engine_dvorak);
 177
 178     ComponentExtensionEngine ext_xkb_engine_colemak;
 179     ext_xkb_engine_colemak.engine_id = "xkb:us:colemak:eng";
 180     ext_xkb_engine_colemak.display_name = "xkb:us:colemak:eng";
 181     ext_xkb_engine_colemak.language_codes.push_back("en-US");
 182     ext_xkb_engine_colemak.layouts.push_back("us(colemak)");
 183     ext_xkb.engines.push_back(ext_xkb_engine_colemak);
 184
 185     ComponentExtensionEngine ext_xkb_engine_fr;
 186     ext_xkb_engine_fr.engine_id = "xkb:fr::fra";
 187     ext_xkb_engine_fr.display_name = "xkb:fr::fra";
 188     ext_xkb_engine_fr.language_codes.push_back("fr");
 189     ext_xkb_engine_fr.layouts.push_back("fr");
 190     ext_xkb.engines.push_back(ext_xkb_engine_fr);
 191
 192     ComponentExtensionEngine ext_xkb_engine_se;
 193     ext_xkb_engine_se.engine_id = "xkb:se::swe";
 194     ext_xkb_engine_se.display_name = "xkb:se::swe";
 195     ext_xkb_engine_se.language_codes.push_back("sv");
 196     ext_xkb_engine_se.layouts.push_back("se");
 197     ext_xkb.engines.push_back(ext_xkb_engine_se);
 198
 199     ComponentExtensionEngine ext_xkb_engine_jp;
 200     ext_xkb_engine_jp.engine_id = "xkb:jp::jpn";
 201     ext_xkb_engine_jp.display_name = "xkb:jp::jpn";
 202     ext_xkb_engine_jp.language_codes.push_back("ja");
 203     ext_xkb_engine_jp.layouts.push_back("jp");
 204     ext_xkb.engines.push_back(ext_xkb_engine_jp);
 205
 206     ComponentExtensionEngine ext_xkb_engine_ru;
 207     ext_xkb_engine_ru.engine_id = "xkb:ru::rus";
 208     ext_xkb_engine_ru.display_name = "xkb:ru::rus";
 209     ext_xkb_engine_ru.language_codes.push_back("ru");
 210     ext_xkb_engine_ru.layouts.push_back("ru");
 211     ext_xkb.engines.push_back(ext_xkb_engine_ru);
 212
 213     ComponentExtensionEngine ext_xkb_engine_hu;
 214     ext_xkb_engine_hu.engine_id = "xkb:hu::hun";
 215     ext_xkb_engine_hu.display_name = "xkb:hu::hun";
 216     ext_xkb_engine_hu.language_codes.push_back("hu");
 217     ext_xkb_engine_hu.layouts.push_back("hu");
 218     ext_xkb.engines.push_back(ext_xkb_engine_hu);
 219
 220     ime_list_.push_back(ext_xkb);
 221
 222     ComponentExtensionIME ext1;
 223     ext1.id = "fpfbhcjppmaeaijcidgiibchfbnhbelj";
 224     ext1.description = "ext1_description";
 225     ext1.path = base::FilePath("ext1_file_path");
 226
 227     ComponentExtensionEngine ext1_engine1;
 228     ext1_engine1.engine_id = "nacl_mozc_us";
 229     ext1_engine1.display_name = "ext1_engine_1_display_name";
 230     ext1_engine1.language_codes.push_back("ja");
 231     ext1_engine1.layouts.push_back("us");
 232     ext1.engines.push_back(ext1_engine1);
 233
 234     ComponentExtensionEngine ext1_engine2;
 235     ext1_engine2.engine_id = "nacl_mozc_jp";
 236     ext1_engine2.display_name = "ext1_engine_1_display_name";
 237     ext1_engine2.language_codes.push_back("ja");
 238     ext1_engine2.layouts.push_back("jp");
 239     ext1.engines.push_back(ext1_engine2);
 240
 241     ime_list_.push_back(ext1);
 242
 243     ComponentExtensionIME ext2;
 244     ext2.id = "gjaehgfemfahhmlgpdfknkhdnemmolop";
 245     ext2.description = "ext2_description";
 246     ext2.path = base::FilePath("ext2_file_path");
 247
 248     ComponentExtensionEngine ext2_engine1;
 249     ext2_engine1.engine_id = "ext2_engine1_engine_id";
 250     ext2_engine1.display_name = "ext2_engine_1_display_name";
 251     ext2_engine1.language_codes.push_back("en");
 252     ext2_engine1.layouts.push_back("us");
 253     ext2.engines.push_back(ext2_engine1);
 254
 255     ComponentExtensionEngine ext2_engine2;
 256     ext2_engine2.engine_id = "ext2_engine2_engine_id";
 257     ext2_engine2.display_name = "ext2_engine_2_display_name";
 258     ext2_engine2.language_codes.push_back("en");
 259     ext2_engine2.layouts.push_back("us(dvorak)");
 260     ext2.engines.push_back(ext2_engine2);
 261
 262     ime_list_.push_back(ext2);
 263   }
 264
 265   TestingBrowserProcess* GetBrowserProcess() {
 266     return TestingBrowserProcess::GetGlobal();
 267   }
 268
 269   scoped_ptr<TestingProfileManager> profile_manager_;
 270   scoped_ptr<InputMethodManagerImpl> manager_;
 271   FakeInputMethodDelegate* delegate_;
 272   MockCandidateWindowController* candidate_window_controller_;
 273   scoped_ptr<MockInputMethodEngine> mock_engine_handler_;
 274   FakeImeKeyboard* keyboard_;
 275   MockComponentExtIMEManagerDelegate* mock_delegate_;
 276   std::vector<ComponentExtensionIME> ime_list_;
 277   ash::ime::InputMethodMenuManager* menu_manager_;
 278
 279  private:
 280   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 281 };
 282
 283 class TestObserver : public InputMethodManager::Observer,
 284                      public ash::ime::InputMethodMenuManager::Observer{
 285  public:
 286   TestObserver()
 287       : input_method_changed_count_(0),
 288         input_method_menu_item_changed_count_(0),
 289         last_show_message_(false) {
 290   }
 291   virtual ~TestObserver() {}
 292
 293   virtual void InputMethodChanged(InputMethodManager* manager,
 294                                   bool show_message) OVERRIDE {
 295     ++input_method_changed_count_;
 296     last_show_message_ = show_message;
 297   }
 298   virtual void InputMethodMenuItemChanged(
 299       ash::ime::InputMethodMenuManager* manager) OVERRIDE {
 300     ++input_method_menu_item_changed_count_;
 301   }
 302
 303   int input_method_changed_count_;
 304   int input_method_menu_item_changed_count_;
 305   bool last_show_message_;
 306
 307  private:
 308   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 309 };
 310
 311 class TestCandidateWindowObserver
 312     : public InputMethodManager::CandidateWindowObserver {
 313  public:
 314   TestCandidateWindowObserver()
 315       : candidate_window_opened_count_(0),
 316         candidate_window_closed_count_(0) {
 317   }
 318   virtual ~TestCandidateWindowObserver() {}
 319
 320   virtual void CandidateWindowOpened(InputMethodManager* manager) OVERRIDE {
 321     ++candidate_window_opened_count_;
 322   }
 323   virtual void CandidateWindowClosed(InputMethodManager* manager) OVERRIDE {
 324     ++candidate_window_closed_count_;
 325   }
 326
 327   int candidate_window_opened_count_;
 328   int candidate_window_closed_count_;
 329
 330  private:
 331   DISALLOW_COPY_AND_ASSIGN(TestCandidateWindowObserver);
 332 };
 333 }  // namespace
 334
 335 TEST_F(InputMethodManagerImplTest, TestGetImeKeyboard) {
 336   EXPECT_TRUE(manager_->GetImeKeyboard());
 337   EXPECT_EQ(keyboard_, manager_->GetImeKeyboard());
 338 }
 339
 340 TEST_F(InputMethodManagerImplTest, TestCandidateWindowObserver) {
 341   TestCandidateWindowObserver observer;
 342   candidate_window_controller_->NotifyCandidateWindowOpened();  // nop
 343   candidate_window_controller_->NotifyCandidateWindowClosed();  // nop
 344   manager_->AddCandidateWindowObserver(&observer);
 345   candidate_window_controller_->NotifyCandidateWindowOpened();
 346   EXPECT_EQ(1, observer.candidate_window_opened_count_);
 347   candidate_window_controller_->NotifyCandidateWindowClosed();
 348   EXPECT_EQ(1, observer.candidate_window_closed_count_);
 349   candidate_window_controller_->NotifyCandidateWindowOpened();
 350   EXPECT_EQ(2, observer.candidate_window_opened_count_);
 351   candidate_window_controller_->NotifyCandidateWindowClosed();
 352   EXPECT_EQ(2, observer.candidate_window_closed_count_);
 353   manager_->RemoveCandidateWindowObserver(&observer);
 354 }
 355
 356 TEST_F(InputMethodManagerImplTest, TestObserver) {
 357   // For http://crbug.com/19655#c11 - (3). browser_state_monitor_unittest.cc is
 358   // also for the scenario.
 359   std::vector<std::string> keyboard_layouts;
 360   keyboard_layouts.push_back("xkb:us::eng");
 361
 362   TestObserver observer;
 363   InitComponentExtension();
 364   manager_->AddObserver(&observer);
 365   menu_manager_->AddObserver(&observer);
 366   EXPECT_EQ(0, observer.input_method_changed_count_);
 367   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 368   EXPECT_EQ(5U, manager_->GetActiveInputMethods()->size());
 369   EXPECT_EQ(1, observer.input_method_changed_count_);
 370   EXPECT_EQ(1, observer.input_method_menu_item_changed_count_);
 371   manager_->ChangeInputMethod(XkbId("xkb:us:dvorak:eng"));
 372   EXPECT_FALSE(observer.last_show_message_);
 373   EXPECT_EQ(2, observer.input_method_changed_count_);
 374   EXPECT_EQ(2, observer.input_method_menu_item_changed_count_);
 375   manager_->ChangeInputMethod(XkbId("xkb:us:dvorak:eng"));
 376   EXPECT_FALSE(observer.last_show_message_);
 377
 378   // The observer is always notified even when the same input method ID is
 379   // passed to ChangeInputMethod() more than twice.
 380   // TODO(komatsu): Revisit if this is neccessary.
 381   EXPECT_EQ(3, observer.input_method_changed_count_);
 382
 383   // If the same input method ID is passed, PropertyChanged() is not
 384   // notified.
 385   EXPECT_EQ(2, observer.input_method_menu_item_changed_count_);
 386
 387   manager_->RemoveObserver(&observer);
 388   menu_manager_->RemoveObserver(&observer);
 389 }
 390
 391 TEST_F(InputMethodManagerImplTest, TestGetSupportedInputMethods) {
 392   InitComponentExtension();
 393   InputMethodDescriptors methods;
 394   if (extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
 395     methods = manager_->GetComponentExtensionIMEManager()
 396                   ->GetXkbIMEAsInputMethodDescriptor();
 397   } else {
 398     methods = *(manager_->GetSupportedInputMethods());
 399   }
 400   // Try to find random 4-5 layuts and IMEs to make sure the returned list is
 401   // correct.
 402   const InputMethodDescriptor* id_to_find =
 403       manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 404           kNaclMozcUsId);
 405   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 406       XkbId("xkb:us::eng"));
 407   EXPECT_TRUE(Contain(methods, *id_to_find));
 408   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 409       XkbId("xkb:us:dvorak:eng"));
 410   EXPECT_TRUE(Contain(methods, *id_to_find));
 411   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 412       XkbId("xkb:fr::fra"));
 413   EXPECT_TRUE(Contain(methods, *id_to_find));
 414 }
 415
 416 TEST_F(InputMethodManagerImplTest, TestEnableLayouts) {
 417   // Currently 5 keyboard layouts are supported for en-US, and 1 for ja. See
 418   // ibus_input_method.txt.
 419   std::vector<std::string> keyboard_layouts;
 420
 421   InitComponentExtension();
 422   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 423   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
 424
 425   // For http://crbug.com/19655#c11 - (5)
 426   // The hardware keyboard layout "xkb:us::eng" is always active, hence 2U.
 427   manager_->EnableLoginLayouts("ja", keyboard_layouts);  // Japanese
 428   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 429 }
 430
 431 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsAndCurrentInputMethod) {
 432   // For http://crbug.com/329061
 433   std::vector<std::string> keyboard_layouts;
 434   keyboard_layouts.push_back(XkbId("xkb:se::swe"));
 435
 436   InitComponentExtension();
 437   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 438   const std::string im_id = manager_->GetCurrentInputMethod().id();
 439   EXPECT_EQ(XkbId("xkb:se::swe"), im_id);
 440 }
 441
 442 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsNonUsHardwareKeyboard) {
 443   InitComponentExtension();
 444   // The physical layout is French.
 445   manager_->GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(
 446       "xkb:fr::fra");
 447   manager_->EnableLoginLayouts(
 448       "en-US",
 449       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
 450   EXPECT_EQ(6U, manager_->GetNumActiveInputMethods());  // 5 + French
 451   // The physical layout is Japanese.
 452   manager_->GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(
 453       "xkb:jp::jpn");
 454   manager_->EnableLoginLayouts(
 455       "ja",
 456       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
 457   // "xkb:us::eng" is not needed, hence 1.
 458   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 459
 460   // The physical layout is Russian.
 461   manager_->GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(
 462       "xkb:ru::rus");
 463   manager_->EnableLoginLayouts(
 464       "ru",
 465       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
 466   // "xkb:us::eng" only.
 467   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 468   EXPECT_EQ(XkbId("xkb:us::eng"),
 469             manager_->GetActiveInputMethodIds().front());
 470 }
 471
 472 TEST_F(InputMethodManagerImplTest, TestEnableMultipleHardwareKeyboardLayout) {
 473   InitComponentExtension();
 474   // The physical layouts are French and Hungarian.
 475   manager_->GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(
 476       "xkb:fr::fra,xkb:hu::hun");
 477   manager_->EnableLoginLayouts(
 478       "en-US",
 479       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
 480   // 5 + French + Hungarian
 481   EXPECT_EQ(7U, manager_->GetNumActiveInputMethods());
 482 }
 483
 484 TEST_F(InputMethodManagerImplTest,
 485        TestEnableMultipleHardwareKeyboardLayout_NoLoginKeyboard) {
 486   InitComponentExtension();
 487   // The physical layouts are English (US) and Russian.
 488   manager_->GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(
 489       "xkb:us::eng,xkb:ru::rus");
 490   manager_->EnableLoginLayouts(
 491       "ru",
 492       manager_->GetInputMethodUtil()->GetHardwareLoginInputMethodIds());
 493   // xkb:us:eng
 494   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 495 }
 496
 497 TEST_F(InputMethodManagerImplTest, TestActiveInputMethods) {
 498   InitComponentExtension();
 499   std::vector<std::string> keyboard_layouts;
 500   manager_->EnableLoginLayouts("ja", keyboard_layouts);  // Japanese
 501   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 502   scoped_ptr<InputMethodDescriptors> methods(
 503       manager_->GetActiveInputMethods());
 504   ASSERT_TRUE(methods.get());
 505   EXPECT_EQ(2U, methods->size());
 506   const InputMethodDescriptor* id_to_find =
 507       manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 508           XkbId("xkb:us::eng"));
 509   EXPECT_TRUE(id_to_find && Contain(*methods.get(), *id_to_find));
 510   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
 511       XkbId("xkb:jp::jpn"));
 512   EXPECT_TRUE(id_to_find && Contain(*methods.get(), *id_to_find));
 513 }
 514
 515 TEST_F(InputMethodManagerImplTest, TestEnableTwoLayouts) {
 516   // For http://crbug.com/19655#c11 - (8), step 6.
 517   TestObserver observer;
 518   manager_->AddObserver(&observer);
 519   InitComponentExtension();
 520   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 521   std::vector<std::string> ids;
 522   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 523   ids.push_back(XkbId("xkb:us:colemak:eng"));
 524   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 525   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 526   // Since all the IDs added avobe are keyboard layouts, Start() should not be
 527   // called.
 528   EXPECT_EQ(1, observer.input_method_changed_count_);
 529   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 530   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 531   // Disable Dvorak.
 532   ids.erase(ids.begin());
 533   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 534   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 535   EXPECT_EQ(2, observer.input_method_changed_count_);
 536   EXPECT_EQ(XkbId(ids[0]),  // colemak
 537             manager_->GetCurrentInputMethod().id());
 538   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 539   manager_->RemoveObserver(&observer);
 540 }
 541
 542 TEST_F(InputMethodManagerImplTest, TestEnableThreeLayouts) {
 543   // For http://crbug.com/19655#c11 - (9).
 544   TestObserver observer;
 545   manager_->AddObserver(&observer);
 546   InitComponentExtension();
 547   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 548   std::vector<std::string> ids;
 549   ids.push_back(XkbId("xkb:us::eng"));
 550   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 551   ids.push_back(XkbId("xkb:us:colemak:eng"));
 552   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 553   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
 554   EXPECT_EQ(1, observer.input_method_changed_count_);
 555   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 556   EXPECT_EQ("us", keyboard_->last_layout_);
 557   // Switch to Dvorak.
 558   manager_->SwitchToNextInputMethod();
 559   EXPECT_EQ(2, observer.input_method_changed_count_);
 560   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 561   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 562   // Disable Dvorak.
 563   ids.erase(ids.begin() + 1);
 564   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 565   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 566   EXPECT_EQ(3, observer.input_method_changed_count_);
 567   EXPECT_EQ(XkbId(ids[0]),  // US Qwerty
 568             manager_->GetCurrentInputMethod().id());
 569   EXPECT_EQ("us", keyboard_->last_layout_);
 570   manager_->RemoveObserver(&observer);
 571 }
 572
 573 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme) {
 574   // For http://crbug.com/19655#c11 - (10).
 575   TestObserver observer;
 576   manager_->AddObserver(&observer);
 577   InitComponentExtension();
 578   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 579   std::vector<std::string> ids;
 580   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 581   ids.push_back(kNaclMozcUsId);
 582   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 583   EXPECT_EQ(1, observer.input_method_changed_count_);
 584   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 585   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 586   // Switch to Mozc
 587   manager_->SwitchToNextInputMethod();
 588   EXPECT_EQ(2, observer.input_method_changed_count_);
 589   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 590   EXPECT_EQ("us", keyboard_->last_layout_);
 591   // Disable Mozc.
 592   ids.erase(ids.begin() + 1);
 593   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 594   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 595   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 596   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 597 }
 598
 599 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme2) {
 600   // For http://crbug.com/19655#c11 - (11).
 601   TestObserver observer;
 602   manager_->AddObserver(&observer);
 603   InitComponentExtension();
 604   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 605   std::vector<std::string> ids;
 606   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 607   ids.push_back(kNaclMozcUsId);
 608   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 609   EXPECT_EQ(1, observer.input_method_changed_count_);
 610   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 611   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 612
 613   // Disable Dvorak.
 614   ids.erase(ids.begin());
 615   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 616   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 617   EXPECT_EQ(XkbId(ids[0]),  // Mozc
 618             manager_->GetCurrentInputMethod().id());
 619   EXPECT_EQ("us", keyboard_->last_layout_);
 620   manager_->RemoveObserver(&observer);
 621 }
 622
 623 TEST_F(InputMethodManagerImplTest, TestEnableImes) {
 624   TestObserver observer;
 625   manager_->AddObserver(&observer);
 626   InitComponentExtension();
 627   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 628   std::vector<std::string> ids;
 629   ids.push_back(kExt2Engine1Id);
 630   ids.push_back("mozc-dv");
 631   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 632   EXPECT_EQ(1, observer.input_method_changed_count_);
 633   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 634   EXPECT_EQ("us", keyboard_->last_layout_);
 635   manager_->RemoveObserver(&observer);
 636 }
 637
 638 TEST_F(InputMethodManagerImplTest, TestEnableUnknownIds) {
 639   TestObserver observer;
 640   manager_->AddObserver(&observer);
 641   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 642   std::vector<std::string> ids;
 643   ids.push_back("xkb:tl::tlh");  // Klingon, which is not supported.
 644   ids.push_back("unknown-super-cool-ime");
 645   EXPECT_FALSE(manager_->ReplaceEnabledInputMethods(ids));
 646
 647   // TODO(yusukes): Should we fall back to the hardware keyboard layout in this
 648   // case?
 649   EXPECT_EQ(0, observer.input_method_changed_count_);
 650
 651   manager_->RemoveObserver(&observer);
 652 }
 653
 654 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsThenLock) {
 655   // For http://crbug.com/19655#c11 - (14).
 656   TestObserver observer;
 657   manager_->AddObserver(&observer);
 658   InitComponentExtension();
 659   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 660   std::vector<std::string> ids;
 661   ids.push_back(XkbId("xkb:us::eng"));
 662   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 663   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 664   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 665   EXPECT_EQ(1, observer.input_method_changed_count_);
 666   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 667   EXPECT_EQ("us", keyboard_->last_layout_);
 668
 669   // Switch to Dvorak.
 670   manager_->SwitchToNextInputMethod();
 671   EXPECT_EQ(2, observer.input_method_changed_count_);
 672   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 673   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 674
 675   // Lock screen
 676   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
 677   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 678   EXPECT_EQ(XkbId(ids[1]),  // still Dvorak
 679             manager_->GetCurrentInputMethod().id());
 680   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 681   // Switch back to Qwerty.
 682   manager_->SwitchToNextInputMethod();
 683   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 684   EXPECT_EQ("us", keyboard_->last_layout_);
 685
 686   // Unlock screen. The original state, Dvorak, is restored.
 687   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 688   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 689   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 690   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 691
 692   manager_->RemoveObserver(&observer);
 693 }
 694
 695 TEST_F(InputMethodManagerImplTest, SwitchInputMethodTest) {
 696   // For http://crbug.com/19655#c11 - (15).
 697   TestObserver observer;
 698   manager_->AddObserver(&observer);
 699   InitComponentExtension();
 700   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 701   std::vector<std::string> ids;
 702   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 703   ids.push_back(kExt2Engine2Id);
 704   ids.push_back(kExt2Engine1Id);
 705   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 706   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
 707   EXPECT_EQ(1, observer.input_method_changed_count_);
 708   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
 709   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 710
 711   // Switch to Mozc.
 712   manager_->SwitchToNextInputMethod();
 713   EXPECT_EQ(2, observer.input_method_changed_count_);
 714   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 715   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 716
 717   // Lock screen
 718   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
 719   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());  // Qwerty+Dvorak.
 720   EXPECT_EQ(XkbId("xkb:us:dvorak:eng"),
 721             manager_->GetCurrentInputMethod().id());
 722   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 723   manager_->SwitchToNextInputMethod();
 724   EXPECT_EQ(XkbId("xkb:us::eng"),  // The hardware keyboard layout.
 725             manager_->GetCurrentInputMethod().id());
 726   EXPECT_EQ("us", keyboard_->last_layout_);
 727
 728   // Unlock screen. The original state, pinyin-dv, is restored.
 729   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 730   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());  // Dvorak and 2 IMEs.
 731   EXPECT_EQ(XkbId(ids[1]), manager_->GetCurrentInputMethod().id());
 732   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 733
 734   manager_->RemoveObserver(&observer);
 735 }
 736
 737 TEST_F(InputMethodManagerImplTest, TestXkbSetting) {
 738   // For http://crbug.com/19655#c11 - (8), step 7-11.
 739   InitComponentExtension();
 740   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 741   std::vector<std::string> ids;
 742   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 743   ids.push_back(XkbId("xkb:us:colemak:eng"));
 744   ids.push_back(kNaclMozcJpId);
 745   ids.push_back(kNaclMozcUsId);
 746   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 747   EXPECT_EQ(4U, manager_->GetNumActiveInputMethods());
 748   EXPECT_EQ(1, keyboard_->set_current_keyboard_layout_by_name_count_);
 749   // See input_methods.txt for an expected XKB layout name.
 750   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 751   manager_->SwitchToNextInputMethod();
 752   EXPECT_EQ(2, keyboard_->set_current_keyboard_layout_by_name_count_);
 753   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 754   manager_->SwitchToNextInputMethod();
 755   EXPECT_EQ(3, keyboard_->set_current_keyboard_layout_by_name_count_);
 756   EXPECT_EQ("jp", keyboard_->last_layout_);
 757   manager_->SwitchToNextInputMethod();
 758   EXPECT_EQ(4, keyboard_->set_current_keyboard_layout_by_name_count_);
 759   EXPECT_EQ("us", keyboard_->last_layout_);
 760   manager_->SwitchToNextInputMethod();
 761   EXPECT_EQ(5, keyboard_->set_current_keyboard_layout_by_name_count_);
 762   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 763   // Disable Dvorak.
 764   ids.erase(ids.begin());
 765   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 766   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
 767   EXPECT_EQ(6, keyboard_->set_current_keyboard_layout_by_name_count_);
 768   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 769 }
 770
 771 TEST_F(InputMethodManagerImplTest, TestActivateInputMethodMenuItem) {
 772   const std::string kKey = "key";
 773   ash::ime::InputMethodMenuItemList menu_list;
 774   menu_list.push_back(ash::ime::InputMethodMenuItem(
 775       kKey, "label", false, false));
 776   menu_manager_->SetCurrentInputMethodMenuItemList(menu_list);
 777
 778   manager_->ActivateInputMethodMenuItem(kKey);
 779   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 780
 781   // Key2 is not registered, so activated property should not be changed.
 782   manager_->ActivateInputMethodMenuItem("key2");
 783   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 784 }
 785
 786 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodProperties) {
 787   InitComponentExtension();
 788   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 789
 790   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 791   std::vector<std::string> ids;
 792   ids.push_back(XkbId("xkb:us::eng"));
 793   ids.push_back(kNaclMozcUsId);
 794   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 795   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 796   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 797   manager_->ChangeInputMethod(kNaclMozcUsId);
 798
 799   ash::ime::InputMethodMenuItemList current_property_list;
 800   current_property_list.push_back(ash::ime::InputMethodMenuItem(
 801       "key", "label", false, false));
 802   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 803
 804   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
 805   EXPECT_EQ("key",
 806             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 807
 808   manager_->ChangeInputMethod("xkb:us::eng");
 809   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 810 }
 811
 812 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
 813   InitComponentExtension();
 814   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 815
 816   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
 817   std::vector<std::string> ids;
 818   ids.push_back(kNaclMozcUsId);  // Japanese
 819   ids.push_back(kExt2Engine1Id);  // T-Chinese
 820   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 821   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 822   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 823
 824   ash::ime::InputMethodMenuItemList current_property_list;
 825   current_property_list.push_back(ash::ime::InputMethodMenuItem("key-mozc",
 826                                                                 "label",
 827                                                                 false,
 828                                                                 false));
 829   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 830
 831   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
 832   EXPECT_EQ("key-mozc",
 833             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 834
 835   manager_->ChangeInputMethod(kExt2Engine1Id);
 836   // Since the IME is changed, the property for mozc Japanese should be hidden.
 837   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 838
 839   // Asynchronous property update signal from mozc-chewing.
 840   current_property_list.clear();
 841   current_property_list.push_back(ash::ime::InputMethodMenuItem(
 842       "key-chewing", "label", false, false));
 843   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 844   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
 845   EXPECT_EQ("key-chewing",
 846             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 847 }
 848
 849 TEST_F(InputMethodManagerImplTest, TestNextInputMethod) {
 850   TestObserver observer;
 851   manager_->AddObserver(&observer);
 852   InitComponentExtension();
 853   std::vector<std::string> keyboard_layouts;
 854   keyboard_layouts.push_back(XkbId("xkb:us::eng"));
 855   // For http://crbug.com/19655#c11 - (1)
 856   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 857   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
 858   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
 859   EXPECT_EQ("us", keyboard_->last_layout_);
 860   manager_->SwitchToNextInputMethod();
 861   EXPECT_TRUE(observer.last_show_message_);
 862   EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
 863   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
 864   manager_->SwitchToNextInputMethod();
 865   EXPECT_TRUE(observer.last_show_message_);
 866   EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
 867             manager_->GetCurrentInputMethod().id());
 868   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 869   manager_->SwitchToNextInputMethod();
 870   EXPECT_TRUE(observer.last_show_message_);
 871   EXPECT_EQ(XkbId("xkb:us:dvorak:eng"),
 872             manager_->GetCurrentInputMethod().id());
 873   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
 874   manager_->SwitchToNextInputMethod();
 875   EXPECT_TRUE(observer.last_show_message_);
 876   EXPECT_EQ(XkbId("xkb:us:colemak:eng"),
 877             manager_->GetCurrentInputMethod().id());
 878   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 879   manager_->SwitchToNextInputMethod();
 880   EXPECT_TRUE(observer.last_show_message_);
 881   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
 882   EXPECT_EQ("us", keyboard_->last_layout_);
 883
 884   manager_->RemoveObserver(&observer);
 885 }
 886
 887 TEST_F(InputMethodManagerImplTest, TestPreviousInputMethod) {
 888   TestObserver observer;
 889   manager_->AddObserver(&observer);
 890   InitComponentExtension();
 891
 892   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
 893   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
 894   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
 895   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 896
 897   std::vector<std::string> keyboard_layouts;
 898   keyboard_layouts.push_back(XkbId("xkb:us::eng"));
 899   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 900   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
 901   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
 902   EXPECT_EQ("us", keyboard_->last_layout_);
 903   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
 904   EXPECT_TRUE(observer.last_show_message_);
 905   EXPECT_EQ(XkbId("xkb:us:intl:eng"),
 906             manager_->GetCurrentInputMethod().id());
 907   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
 908   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 909   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 910   EXPECT_TRUE(observer.last_show_message_);
 911   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
 912   EXPECT_EQ("us", keyboard_->last_layout_);
 913   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 914   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 915   EXPECT_TRUE(observer.last_show_message_);
 916   EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
 917   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
 918   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 919   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 920   EXPECT_TRUE(observer.last_show_message_);
 921   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
 922   EXPECT_EQ("us", keyboard_->last_layout_);
 923   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
 924   EXPECT_TRUE(observer.last_show_message_);
 925   EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
 926   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
 927   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
 928   EXPECT_TRUE(observer.last_show_message_);
 929   EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
 930             manager_->GetCurrentInputMethod().id());
 931   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 932   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 933   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 934   EXPECT_TRUE(observer.last_show_message_);
 935   EXPECT_EQ(XkbId("xkb:us:intl:eng"), manager_->GetCurrentInputMethod().id());
 936   EXPECT_EQ("us(intl)", keyboard_->last_layout_);
 937   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 938   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 939   EXPECT_TRUE(observer.last_show_message_);
 940   EXPECT_EQ(XkbId("xkb:us:altgr-intl:eng"),
 941             manager_->GetCurrentInputMethod().id());
 942   EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 943
 944   manager_->RemoveObserver(&observer);
 945 }
 946
 947 TEST_F(InputMethodManagerImplTest,
 948        TestSwitchToPreviousInputMethodForOneActiveInputMethod) {
 949   TestObserver observer;
 950   manager_->AddObserver(&observer);
 951   InitComponentExtension();
 952
 953   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
 954   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
 955   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
 956   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 957
 958   std::vector<std::string> ids;
 959   ids.push_back(XkbId("xkb:us:dvorak:eng"));
 960   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
 961   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 962
 963   // Ctrl+Space accelerator should not be consumed if there is only one active
 964   // input method.
 965   EXPECT_FALSE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
 966   EXPECT_FALSE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 967
 968   manager_->RemoveObserver(&observer);
 969 }
 970
 971 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithUsLayouts) {
 972   std::string expect_id = XkbId("xkb:us::eng");
 973   TestObserver observer;
 974   manager_->AddObserver(&observer);
 975   InitComponentExtension();
 976   std::vector<std::string> keyboard_layouts;
 977   keyboard_layouts.push_back(XkbId("xkb:us::eng"));
 978   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
 979   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
 980   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
 981   EXPECT_EQ("us", keyboard_->last_layout_);
 982
 983   // Henkan, Muhenkan, ZenkakuHankaku should be ignored when no Japanese IMEs
 984   // and keyboards are enabled.
 985   EXPECT_FALSE(manager_->SwitchInputMethod(
 986       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
 987   EXPECT_FALSE(observer.last_show_message_);
 988   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
 989   EXPECT_EQ("us", keyboard_->last_layout_);
 990   EXPECT_FALSE(manager_->SwitchInputMethod(
 991       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
 992   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
 993   EXPECT_EQ("us", keyboard_->last_layout_);
 994   EXPECT_FALSE(manager_->SwitchInputMethod(
 995       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
 996   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
 997   EXPECT_EQ("us", keyboard_->last_layout_);
 998   EXPECT_FALSE(manager_->SwitchInputMethod(
 999       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
1000   EXPECT_EQ(expect_id, manager_->GetCurrentInputMethod().id());
1001   EXPECT_EQ("us", keyboard_->last_layout_);
1002
1003   manager_->RemoveObserver(&observer);
1004 }
1005
1006 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpLayout) {
1007   // Enable "xkb:jp::jpn" and press Muhenkan/ZenkakuHankaku.
1008   InitComponentExtension();
1009
1010   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
1011   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
1012   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
1013   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
1014
1015   std::vector<std::string> keyboard_layouts;
1016   keyboard_layouts.push_back(XkbId("xkb:us::eng"));
1017   manager_->EnableLoginLayouts("ja", keyboard_layouts);
1018   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1019   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
1020   EXPECT_EQ("us", keyboard_->last_layout_);
1021   EXPECT_TRUE(manager_->SwitchInputMethod(
1022       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
1023   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1024   EXPECT_EQ("jp", keyboard_->last_layout_);
1025   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
1026   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
1027   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
1028   EXPECT_EQ("us", keyboard_->last_layout_);
1029   EXPECT_TRUE(manager_->SwitchInputMethod(
1030       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
1031   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1032   EXPECT_EQ("jp", keyboard_->last_layout_);
1033   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
1034   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
1035   EXPECT_EQ(XkbId("xkb:us::eng"), manager_->GetCurrentInputMethod().id());
1036   EXPECT_EQ("us", keyboard_->last_layout_);
1037   EXPECT_TRUE(manager_->SwitchInputMethod(
1038       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
1039   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1040   EXPECT_EQ("jp", keyboard_->last_layout_);
1041 }
1042
1043 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpIme) {
1044   InitComponentExtension();
1045   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1046   std::vector<std::string> ids;
1047   ids.push_back(XkbId("xkb:jp::jpn"));
1048   ids.push_back(kNaclMozcJpId);
1049   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1050   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1051   EXPECT_EQ("jp", keyboard_->last_layout_);
1052   EXPECT_TRUE(manager_->SwitchInputMethod(
1053       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
1054   EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
1055   EXPECT_EQ("jp", keyboard_->last_layout_);
1056   EXPECT_TRUE(manager_->SwitchInputMethod(
1057       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
1058   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1059   EXPECT_EQ("jp", keyboard_->last_layout_);
1060   EXPECT_TRUE(manager_->SwitchInputMethod(
1061       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
1062   EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
1063   EXPECT_EQ("jp", keyboard_->last_layout_);
1064   EXPECT_TRUE(manager_->SwitchInputMethod(
1065       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
1066   EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
1067   EXPECT_EQ("jp", keyboard_->last_layout_);
1068   EXPECT_TRUE(manager_->SwitchInputMethod(
1069       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
1070   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1071   EXPECT_EQ("jp", keyboard_->last_layout_);
1072   EXPECT_TRUE(manager_->SwitchInputMethod(
1073       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
1074   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1075   EXPECT_EQ("jp", keyboard_->last_layout_);
1076
1077   // Add Dvorak.
1078   ids.push_back(XkbId("xkb:us:dvorak:eng"));
1079   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1080   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1081   EXPECT_EQ("jp", keyboard_->last_layout_);
1082   EXPECT_TRUE(manager_->SwitchInputMethod(
1083       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
1084   EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
1085   EXPECT_EQ("jp", keyboard_->last_layout_);
1086   EXPECT_TRUE(manager_->SwitchInputMethod(
1087       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
1088   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
1089   EXPECT_EQ("jp", keyboard_->last_layout_);
1090 }
1091
1092 TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
1093   TestObserver observer;
1094   manager_->AddObserver(&observer);
1095   InitComponentExtension();
1096   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1097   std::vector<std::string> ids;
1098   ids.push_back(XkbId("xkb:us:dvorak:eng"));
1099   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1100   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1101   EXPECT_EQ(1, observer.input_method_changed_count_);
1102   EXPECT_EQ(XkbId(ids[0]),
1103             manager_->GetCurrentInputMethod().id());
1104   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
1105
1106   // Add two Extension IMEs.
1107   std::vector<std::string> layouts;
1108   layouts.push_back("us");
1109   std::vector<std::string> languages;
1110   languages.push_back("en-US");
1111
1112   const std::string ext1_id =
1113       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
1114   const InputMethodDescriptor descriptor1(ext1_id,
1115                                           "deadbeef input method",
1116                                           "DB",
1117                                           layouts,
1118                                           languages,
1119                                           false,  // is_login_keyboard
1120                                           GURL(),
1121                                           GURL());
1122   MockInputMethodEngine engine(descriptor1);
1123   manager_->AddInputMethodExtension(ext1_id, &engine);
1124
1125   // Extension IMEs are not enabled by default.
1126   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1127
1128   std::vector<std::string> extension_ime_ids;
1129   extension_ime_ids.push_back(ext1_id);
1130   manager_->SetEnabledExtensionImes(&extension_ime_ids);
1131   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1132
1133   {
1134     scoped_ptr<InputMethodDescriptors> methods(
1135         manager_->GetActiveInputMethods());
1136     ASSERT_EQ(2U, methods->size());
1137     // Ext IMEs should be at the end of the list.
1138     EXPECT_EQ(ext1_id, methods->at(1).id());
1139   }
1140
1141   const std::string ext2_id =
1142       extension_ime_util::GetInputMethodID("cafebabe", "engine_id");
1143   const InputMethodDescriptor descriptor2(ext2_id,
1144                                           "cafebabe input method",
1145                                           "CB",
1146                                           layouts,
1147                                           languages,
1148                                           false,  // is_login_keyboard
1149                                           GURL(),
1150                                           GURL());
1151   MockInputMethodEngine engine2(descriptor2);
1152   manager_->AddInputMethodExtension(ext2_id, &engine2);
1153   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1154
1155   extension_ime_ids.push_back(ext2_id);
1156   manager_->SetEnabledExtensionImes(&extension_ime_ids);
1157   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
1158   {
1159     scoped_ptr<InputMethodDescriptors> methods(
1160         manager_->GetActiveInputMethods());
1161     ASSERT_EQ(3U, methods->size());
1162     // Ext IMEs should be at the end of the list.
1163     EXPECT_EQ(ext1_id, methods->at(1).id());
1164     EXPECT_EQ(ext2_id, methods->at(2).id());
1165   }
1166
1167   // Remove them.
1168   manager_->RemoveInputMethodExtension(ext1_id);
1169   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1170   manager_->RemoveInputMethodExtension(ext2_id);
1171   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1172 }
1173
1174 TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
1175   TestObserver observer;
1176   InitComponentExtension();
1177   manager_->AddObserver(&observer);
1178   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1179   std::vector<std::string> ids;
1180   ids.push_back(XkbId("xkb:us::eng"));
1181   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1182   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1183   EXPECT_EQ(1, observer.input_method_changed_count_);
1184   EXPECT_EQ(XkbId(ids[0]), manager_->GetCurrentInputMethod().id());
1185   EXPECT_EQ("us", keyboard_->last_layout_);
1186
1187   // Add an Extension IME.
1188   std::vector<std::string> layouts;
1189   layouts.push_back("us(dvorak)");
1190   std::vector<std::string> languages;
1191   languages.push_back("en-US");
1192
1193   const std::string ext_id =
1194       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
1195   const InputMethodDescriptor descriptor(ext_id,
1196                                          "deadbeef input method",
1197                                          "DB",
1198                                          layouts,
1199                                          languages,
1200                                          false,  // is_login_keyboard
1201                                          GURL(),
1202                                          GURL());
1203   MockInputMethodEngine engine(descriptor);
1204   manager_->AddInputMethodExtension(ext_id, &engine);
1205
1206   // Extension IME is not enabled by default.
1207   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1208   EXPECT_EQ(1, observer.input_method_changed_count_);
1209
1210   std::vector<std::string> extension_ime_ids;
1211   extension_ime_ids.push_back(ext_id);
1212   manager_->SetEnabledExtensionImes(&extension_ime_ids);
1213   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1214
1215   // Switch to the IME.
1216   manager_->SwitchToNextInputMethod();
1217   EXPECT_EQ(3, observer.input_method_changed_count_);
1218   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
1219   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
1220
1221   // Lock the screen. This is for crosbug.com/27049.
1222   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
1223   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());  // Qwerty. No Ext. IME
1224   EXPECT_EQ(XkbId("xkb:us::eng"),
1225             manager_->GetCurrentInputMethod().id());
1226   EXPECT_EQ("us", keyboard_->last_layout_);
1227
1228   // Unlock the screen.
1229   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1230   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1231   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
1232   EXPECT_EQ("us(dvorak)", keyboard_->last_layout_);
1233   {
1234     // This is for crosbug.com/27052.
1235     scoped_ptr<InputMethodDescriptors> methods(
1236         manager_->GetActiveInputMethods());
1237     ASSERT_EQ(2U, methods->size());
1238     // Ext. IMEs should be at the end of the list.
1239     EXPECT_EQ(ext_id, methods->at(1).id());
1240   }
1241   manager_->RemoveObserver(&observer);
1242 }
1243
1244 TEST_F(InputMethodManagerImplTest,
1245        ChangeInputMethodBeforeComponentExtensionInitialization_OneIME) {
1246   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1247   std::vector<std::string> ids;
1248   ids.push_back(kNaclMozcUsId);
1249   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1250   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1251   manager_->ChangeInputMethod(kNaclMozcUsId);
1252
1253   InitComponentExtension();
1254   EXPECT_EQ(kNaclMozcUsId, manager_->GetCurrentInputMethod().id());
1255 }
1256
1257 TEST_F(InputMethodManagerImplTest,
1258        ChangeInputMethodBeforeComponentExtensionInitialization_TwoIME) {
1259   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1260   std::vector<std::string> ids;
1261   ids.push_back(kNaclMozcUsId);
1262   ids.push_back(kNaclMozcJpId);
1263   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1264   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1265   manager_->ChangeInputMethod(kNaclMozcUsId);
1266   manager_->ChangeInputMethod(kNaclMozcJpId);
1267
1268   InitComponentExtension();
1269   EXPECT_EQ(kNaclMozcJpId, manager_->GetCurrentInputMethod().id());
1270 }
1271
1272 TEST_F(InputMethodManagerImplTest,
1273        ChangeInputMethodBeforeComponentExtensionInitialization_CompOneIME) {
1274   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1275   const std::string ext_id = extension_ime_util::GetComponentInputMethodID(
1276       ime_list_[1].id,
1277       ime_list_[1].engines[0].engine_id);
1278   std::vector<std::string> ids;
1279   ids.push_back(ext_id);
1280   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1281   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1282   manager_->ChangeInputMethod(ext_id);
1283
1284   InitComponentExtension();
1285   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
1286 }
1287
1288 TEST_F(InputMethodManagerImplTest,
1289        ChangeInputMethodBeforeComponentExtensionInitialization_CompTwoIME) {
1290   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1291   const std::string ext_id1 = extension_ime_util::GetComponentInputMethodID(
1292       ime_list_[1].id,
1293       ime_list_[1].engines[0].engine_id);
1294   const std::string ext_id2 = extension_ime_util::GetComponentInputMethodID(
1295       ime_list_[2].id,
1296       ime_list_[2].engines[0].engine_id);
1297   std::vector<std::string> ids;
1298   ids.push_back(ext_id1);
1299   ids.push_back(ext_id2);
1300   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1301   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1302   manager_->ChangeInputMethod(ext_id1);
1303   manager_->ChangeInputMethod(ext_id2);
1304
1305   InitComponentExtension();
1306   EXPECT_EQ(ext_id2, manager_->GetCurrentInputMethod().id());
1307 }
1308
1309 TEST_F(InputMethodManagerImplTest,
1310        ChangeInputMethod_ComponenteExtensionOneIME) {
1311   InitComponentExtension();
1312   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1313   const std::string ext_id = extension_ime_util::GetComponentInputMethodID(
1314       ime_list_[1].id,
1315       ime_list_[1].engines[0].engine_id);
1316   std::vector<std::string> ids;
1317   ids.push_back(ext_id);
1318   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1319   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
1320   EXPECT_EQ(ext_id, manager_->GetCurrentInputMethod().id());
1321 }
1322
1323 TEST_F(InputMethodManagerImplTest,
1324        ChangeInputMethod_ComponenteExtensionTwoIME) {
1325   InitComponentExtension();
1326   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
1327   const std::string ext_id1 = extension_ime_util::GetComponentInputMethodID(
1328       ime_list_[1].id,
1329       ime_list_[1].engines[0].engine_id);
1330   const std::string ext_id2 = extension_ime_util::GetComponentInputMethodID(
1331       ime_list_[2].id,
1332       ime_list_[2].engines[0].engine_id);
1333   std::vector<std::string> ids;
1334   ids.push_back(ext_id1);
1335   ids.push_back(ext_id2);
1336   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
1337   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
1338   EXPECT_EQ(ext_id1, manager_->GetCurrentInputMethod().id());
1339   manager_->ChangeInputMethod(ext_id2);
1340   EXPECT_EQ(ext_id2, manager_->GetCurrentInputMethod().id());
1341 }
1342
1343 TEST_F(InputMethodManagerImplTest, MigrateInputMethodTest_1) {
1344   extension_ime_util::ScopedUseExtensionKeyboardFlagForTesting
1345       scoped_flag(true);
1346
1347   std::vector<std::string> input_method_ids;
1348   input_method_ids.push_back("xkb:us::eng");
1349   input_method_ids.push_back("xkb:fr::fra");
1350   input_method_ids.push_back(
1351       std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
1352   input_method_ids.push_back("xkb:fr::fra");
1353   input_method_ids.push_back(
1354       std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
1355   input_method_ids.push_back("_comp_ime_asdf_pinyin");
1356   input_method_ids.push_back(kPinyinImeId);
1357
1358   manager_->MigrateXkbInputMethods(&input_method_ids);
1359
1360   ASSERT_EQ(4U, input_method_ids.size());
1361
1362   EXPECT_EQ(std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng",
1363             input_method_ids[0]);
1364   EXPECT_EQ(std::string("_comp_ime_") + kXkbExtId + "xkb:fr::fra",
1365             input_method_ids[1]);
1366   EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
1367   EXPECT_EQ("_comp_ime_gjaehgfemfahhmlgpdfknkhdnemmolopzh-t-i0-pinyin",
1368             input_method_ids[3]);
1369 }
1370
1371 TEST_F(InputMethodManagerImplTest, MigrateInputMethodTest_2) {
1372   extension_ime_util::ScopedUseExtensionKeyboardFlagForTesting
1373       scoped_flag(false);
1374
1375   std::vector<std::string> input_method_ids;
1376   input_method_ids.push_back("xkb:us::eng");
1377   input_method_ids.push_back("xkb:fr::fra");
1378   input_method_ids.push_back(
1379       std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
1380   input_method_ids.push_back("xkb:fr::fra");
1381   input_method_ids.push_back(
1382       std::string("_comp_ime_") + kXkbExtId + "xkb:us::eng");
1383   input_method_ids.push_back("_comp_ime_asdf_pinyin");
1384
1385   manager_->MigrateXkbInputMethods(&input_method_ids);
1386
1387   ASSERT_EQ(3U, input_method_ids.size());
1388
1389   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
1390   EXPECT_EQ("xkb:fr::fra", input_method_ids[1]);
1391   EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
1392 }
1393
1394 }  // namespace input_method
1395 }  // namespace chromeos