ozone: Rename XKeyboard to KeyboardController & use fake under ozone

chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/input_method/input_method_manager_impl.h"
 
 #include <algorithm>
 
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_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 "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/events/keycodes/keyboard_codes.h"
 
 namespace chromeos {
 
 namespace input_method {
 namespace {
@@ skipping 27 matching lines @@
 
 std::string XkbId(const std::string& id) {
   return extension_ime_util::GetInputMethodIDByKeyboardLayout(id);
 }
 
 class InputMethodManagerImplTest :  public testing::Test {
  public:
   InputMethodManagerImplTest()
       : delegate_(NULL),
         candidate_window_controller_(NULL),
-        xkeyboard_(NULL) {
+        keyboard_(NULL) {
   }
   virtual ~InputMethodManagerImplTest() {}
 
   virtual void SetUp() OVERRIDE {
     delegate_ = new FakeInputMethodDelegate();
     manager_.reset(new InputMethodManagerImpl(
         scoped_ptr<InputMethodDelegate>(delegate_)));
     manager_->GetInputMethodUtil()->UpdateHardwareLayoutCache();
     candidate_window_controller_ = new MockCandidateWindowController;
     manager_->SetCandidateWindowControllerForTesting(
         candidate_window_controller_);
-    xkeyboard_ = new FakeXKeyboard;
-    manager_->SetXKeyboardForTesting(xkeyboard_);
+    keyboard_ = new FakeImeKeyboard;
+    manager_->SetImeKeyboardForTesting(keyboard_);
     mock_engine_handler_.reset(new MockIMEEngineHandler());
     IMEBridge::Initialize();
     IMEBridge::Get()->SetCurrentEngineHandler(mock_engine_handler_.get());
 
     menu_manager_ = ash::ime::InputMethodMenuManager::GetInstance();
 
     ime_list_.clear();
 
     ComponentExtensionIME ext_xkb;
     ext_xkb.id = kXkbExtId;
@@ skipping 111 matching lines @@
     ext2_engine2.language_codes.push_back("en");
     ext2_engine2.layouts.push_back("us(dvorak)");
     ext2.engines.push_back(ext2_engine2);
 
     ime_list_.push_back(ext2);
   }
 
   virtual void TearDown() OVERRIDE {
     delegate_ = NULL;
     candidate_window_controller_ = NULL;
-    xkeyboard_ = NULL;
+    keyboard_ = 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();
@@ skipping 10 matching lines @@
                                         mock_engine_handler_.get());
     IMEBridge::Get()->SetEngineHandler(kExt2Engine2Id,
                                         mock_engine_handler_.get());
     manager_->InitializeComponentExtensionForTesting(delegate.Pass());
   }
 
   scoped_ptr<InputMethodManagerImpl> manager_;
   FakeInputMethodDelegate* delegate_;
   MockCandidateWindowController* candidate_window_controller_;
   scoped_ptr<MockIMEEngineHandler> mock_engine_handler_;
-  FakeXKeyboard* xkeyboard_;
+  FakeImeKeyboard* keyboard_;
   base::MessageLoop message_loop_;
   MockComponentExtIMEManagerDelegate* mock_delegate_;
   std::vector<ComponentExtensionIME> ime_list_;
   ash::ime::InputMethodMenuManager* menu_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 };
 
 class TestObserver : public InputMethodManager::Observer,
@@ skipping 41 matching lines @@
   }
 
   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) {
   TestCandidateWindowObserver observer;
   candidate_window_controller_->NotifyCandidateWindowOpened();  // nop
   candidate_window_controller_->NotifyCandidateWindowClosed();  // nop
   manager_->AddCandidateWindowObserver(&observer);
   candidate_window_controller_->NotifyCandidateWindowOpened();
   EXPECT_EQ(1, observer.candidate_window_opened_count_);
   candidate_window_controller_->NotifyCandidateWindowClosed();
@@ skipping 172 matching lines @@
   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"));
   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("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
             manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us(colemak)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableThreeLayouts) {
   // For http://crbug.com/19655#c11 - (9).
   TestObserver observer;
   manager_->AddObserver(&observer);
   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"));
   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("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("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
             manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme) {
   // For http://crbug.com/19655#c11 - (10).
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(XkbId("xkb:us:dvorak:eng"));
   ids.push_back(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("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("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("us(dvorak)", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme2) {
   // For http://crbug.com/19655#c11 - (11).
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(XkbId("xkb:us:dvorak:eng"));
   ids.push_back(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("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
             manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us", xkeyboard_->last_layout_);
+  EXPECT_EQ("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableImes) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(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("us", keyboard_->last_layout_);
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableUnknownIds) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:tl::tlh");  // Klingon, which is not supported.
   ids.push_back("unknown-super-cool-ime");
@@ skipping 12 matching lines @@
   manager_->AddObserver(&observer);
   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"));
   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("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("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
             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("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("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, SwitchInputMethodTest) {
   // For http://crbug.com/19655#c11 - (15).
   TestObserver observer;
   manager_->AddObserver(&observer);
   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);
   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("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("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"),
             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.
             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("us(dvorak)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestXkbSetting) {
   // For http://crbug.com/19655#c11 - (8), step 7-11.
   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);
   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) {
   const std::string kKey = "key";
   ash::ime::InputMethodMenuItemList menu_list;
   menu_list.push_back(ash::ime::InputMethodMenuItem(
       kKey, "label", false, false));
   menu_manager_->SetCurrentInputMethodMenuItemList(menu_list);
 
   manager_->ActivateInputMethodMenuItem(kKey);
@@ skipping 70 matching lines @@
 TEST_F(InputMethodManagerImplTest, TestNextInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(XkbId("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("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("us(intl)", keyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
   EXPECT_EQ(XkbId("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"),
             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"),
             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("us", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestPreviousInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
 
   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(XkbId("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("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("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("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("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("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("us(intl)", keyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
   EXPECT_TRUE(observer.last_show_message_);
   EXPECT_EQ(XkbId("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("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"),
             manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("us(altgr-intl)", xkeyboard_->last_layout_);
+  EXPECT_EQ("us(altgr-intl)", keyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest,
        TestSwitchToPreviousInputMethodForOneActiveInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
 
@@ skipping 18 matching lines @@
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithUsLayouts) {
   std::string expect_id = XkbId("xkb:us::eng");
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(XkbId("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.
   EXPECT_FALSE(manager_->SwitchInputMethod(
       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);
 }
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpLayout) {
   // Enable "xkb:jp::jpn" and press Muhenkan/ZenkakuHankaku.
   InitComponentExtension();
 
   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back(XkbId("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("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("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("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("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("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("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);
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(XkbId("xkb:jp::jpn"), manager_->GetCurrentInputMethod().id());
-  EXPECT_EQ("jp", xkeyboard_->last_layout_);
+  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("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("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("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("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("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("jp", keyboard_->last_layout_);
 
   // Add Dvorak.
   ids.push_back(XkbId("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("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("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("jp", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestAddRemoveExtensionInputMethods) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(XkbId("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("us(dvorak)", keyboard_->last_layout_);
 
   // Add two Extension IMEs.
   std::vector<std::string> layouts;
   layouts.push_back("us");
   std::vector<std::string> languages;
   languages.push_back("en-US");
 
   const std::string ext1_id =
       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
   const InputMethodDescriptor descriptor1(ext1_id,
@@ skipping 60 matching lines @@
   TestObserver observer;
   InitComponentExtension();
   manager_->AddObserver(&observer);
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(XkbId("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("us", keyboard_->last_layout_);
 
   // Add an Extension IME.
   std::vector<std::string> layouts;
   layouts.push_back("us(dvorak)");
   std::vector<std::string> languages;
   languages.push_back("en-US");
 
   const std::string ext_id =
       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
   const InputMethodDescriptor descriptor(ext_id,
@@ skipping 13 matching lines @@
 
   std::vector<std::string> extension_ime_ids;
   extension_ime_ids.push_back(ext_id);
   manager_->SetEnabledExtensionImes(&extension_ime_ids);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 
   // Switch to the IME.
   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"),
             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(
         manager_->GetActiveInputMethods());
     ASSERT_EQ(2U, methods->size());
     // Ext. IMEs should be at the end of the list.
     EXPECT_EQ(ext_id, methods->at(1).id());
   }
   manager_->RemoveObserver(&observer);
 }
@@ skipping 143 matching lines @@
 
   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("_comp_ime_asdf_pinyin", input_method_ids[2]);
 }
 
 }  // namespace input_method
 }  // namespace chromeos