Convert sticky keys to a chromeos::EventRewriter phase.

chrome/browser/chromeos/events/event_rewriter_unittest.cc

 // Copyright 2014 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/events/event_rewriter.h"
 
-#include <X11/keysym.h>
-#include <X11/XF86keysym.h>
-#include <X11/Xlib.h>
-#undef Bool
-#undef None
-#undef RootWindow
-
 #include <vector>
 
+#include "ash/shell.h"
+#include "ash/sticky_keys/sticky_keys_controller.h"
+#include "ash/sticky_keys/sticky_keys_overlay.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/window_state.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_member.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/fake_ime_keyboard.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
+#include "ui/events/test/test_event_processor.h"
+
+#if defined(USE_X11)
+#include <X11/keysym.h>
+
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/x/x11_types.h"
+#endif
 
 namespace {
 
+// The device id of the test touchpad device.
+const unsigned int kTouchPadDeviceId = 1;
+
 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type) {
   return base::StringPrintf("ui_keycode=0x%X ui_flags=0x%X ui_type=%d",
                             ui_keycode,
                             ui_flags & ~ui::EF_IS_REPEAT,
                             ui_type);
 }
 
 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) {
@@ skipping 134 matching lines @@
 #endif
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class EventRewriterTest : public ash::test::AshTestBase {
  public:
   EventRewriterTest()
-      : display_(gfx::GetXDisplay()),
-        mock_user_manager_(new chromeos::MockUserManager),
+      : mock_user_manager_(new chromeos::MockUserManager),
         user_manager_enabler_(mock_user_manager_),
         input_method_manager_mock_(NULL) {}
   virtual ~EventRewriterTest() {}
 
   virtual void SetUp() {
     // Mocking user manager because the real one needs to be called on UI thread
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
         .WillRepeatedly(testing::Return(false));
     input_method_manager_mock_ =
         new chromeos::input_method::MockInputMethodManager;
@@ skipping 13 matching lines @@
   void TestRewriteNumPadKeys();
   void TestRewriteNumPadKeysOnAppleKeyboard();
 
   int RewriteMouseEvent(chromeos::EventRewriter* rewriter,
                         const ui::MouseEvent& event) {
     int flags = event.flags();
     rewriter->RewriteLocatedEventForTesting(event, &flags);
     return flags;
   }
 
-  Display* display_;
   chromeos::MockUserManager* mock_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
   // First, test with a PC keyboard.
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase pc_keyboard_tests[] = {
       // VKEY_A, Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN}},
 
@@ skipping 60 matching lines @@
 
 // For crbug.com/133896.
 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
   rewriter.set_last_device_id_for_testing(0);
 
   KeyTestCase pc_keyboard_tests[] = {// Control should be remapped to Alt.
                                      {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
                                       {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN},
                                       {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
   };
 
@@ skipping 19 matching lines @@
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) {
     CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]);
   }
 }
 
 void EventRewriterTest::TestRewriteNumPadKeys() {
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}},
 
       // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
@@ skipping 121 matching lines @@
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestRewriteNumPadKeys();
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 // Tests if the rewriter can handle a Command + Num Pad event.
 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
       // The result should be "Num Pad 1 with Control + Num Lock modifiers".
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_END, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}},
@@ skipping 21 matching lines @@
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestRewriteNumPadKeysOnAppleKeyboard();
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press Search. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_NONE},
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}},
 
       // Press left Control. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 22 matching lines @@
        {ui::VKEY_LWIN, ui::EF_NONE}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press Alt with Shift. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
 
       // Press Search with Caps Lock mask. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 22 matching lines @@
   // Disable Search and Control keys.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kVoidKey);
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kVoidKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase disabled_modifier_tests[] = {
       // Press Alt with Shift. This key press shouldn't be affected by the
       // pref. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
 
       // Press Search. Confirm the event is now VKEY_UNKNOWN.
@@ skipping 54 matching lines @@
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
   // Remap Search to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kControlKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase s_tests[] = {
       // Press Search. Confirm the event is now VKEY_CONTROL.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(s_tests); ++i) {
@@ skipping 43 matching lines @@
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
   // Remap Search to ESC.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kEscapeKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {// Press Search. Confirm the event is now VKEY_ESCAPE.
                          {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
                           {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
                           {ui::VKEY_ESCAPE, ui::EF_NONE}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
   // Remap Search to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kAltKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase s2a_tests[] = {
       // Press Search. Confirm the event is now VKEY_MENU.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
        {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(s2a_tests); ++i) {
@@ skipping 56 matching lines @@
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
   // Remap Search to Caps Lock.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kCapsLockKey);
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // Press Search.
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_CAPITAL,
                                 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
                                 ui::ET_KEY_PRESSED),
       GetRewrittenEventAsString(
@@ skipping 49 matching lines @@
             GetRewrittenEventAsString(
                 &rewriter, ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED));
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 }
 
 TEST_F(EventRewriterTest, TestRewriteCapsLock) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
                                       ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
                                       ui::ET_KEY_PRESSED),
             GetRewrittenEventAsString(
                 &rewriter, ui::VKEY_F16, ui::EF_MOD3_DOWN, ui::ET_KEY_PRESSED));
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 }
 
 TEST_F(EventRewriterTest, TestRewriteDiamondKey) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
 
   KeyTestCase tests[] = {
       // F15 should work as Ctrl when --has-chromeos-diamond-key is not
       // specified.
       {KeyTestCase::TEST_VKEY,
        ui::ET_KEY_PRESSED,
        {ui::VKEY_F15, ui::EF_NONE},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
@@ skipping 12 matching lines @@
 }
 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
 
   // By default, F15 should work as Control.
   EXPECT_EQ(GetExpectedResultAsString(
                 ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED),
             GetRewrittenEventAsString(
                 &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED));
 
   IntegerPrefMember diamond;
@@ skipping 31 matching lines @@
 }
 
 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
   // Remap CapsLock to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kControlKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
       // On Chrome OS, CapsLock works as a Mod3 modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_MOD3_DOWN},
        {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
 
       // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to
@@ skipping 15 matching lines @@
 }
 
 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
   // Remap CapsLock to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kControlKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   input_method_manager_mock_->set_mod3_used(true);
 
   // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
   // when Mod3Mask is already in use by the current XKB layout.
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED),
       GetRewrittenEventAsString(
           &rewriter, ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED));
 
   input_method_manager_mock_->set_mod3_used(false);
 }
 
 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Alt+Backspace -> Delete
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::EF_ALT_DOWN},
        {ui::VKEY_DELETE, ui::EF_NONE}},
       // Control+Alt+Backspace -> Control+Delete
@@ skipping 88 matching lines @@
        {ui::VKEY_INSERT, ui::EF_CONTROL_DOWN}}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   FunctionKeyTestCase tests[] = {
       // F1 -> Back
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::EF_NONE},
        {ui::VKEY_BROWSER_BACK, ui::EF_NONE},
        {ui::VKEY_BROWSER_BACK, ui::EF_FUNCTION_KEY}},
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::EF_CONTROL_DOWN},
@@ skipping 307 matching lines @@
 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
 
   // Remap Search to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kControlKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSKeyboard, "");
 
   KeyTestCase tests[] = {
       // Alt+Search+Down -> End
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_END, ui::EF_NONE}},
 
       // Shift+Alt+Search+Down -> Shift+End
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_END, ui::EF_SHIFT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
   }
 
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
+#if defined(USE_X11)
+  // TODO(kpschoedel): pending alternative to xevent.xany.send_event
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Send left control press.
   std::string rewritten_event;
   {
     ui::ScopedXI2Event xev;
     xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
     XEvent* xevent = xev;
     xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
     xevent->xkey.send_event = True;  // XSendEvent() always does this.
     ui::KeyEvent keyevent(xev, false /* is_char */);
     scoped_ptr<ui::Event> new_event;
     // Control should NOT be remapped to Alt if send_event
     // flag in the event is True.
     EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
               rewriter.RewriteEvent(keyevent, &new_event));
     EXPECT_FALSE(new_event);
   }
+#endif
 }
 
 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   const int kTouchId = 2;
   gfx::Point location(0, 0);
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, location, kTouchId, base::TimeDelta());
   press.set_flags(ui::EF_CONTROL_DOWN);
 
   scoped_ptr<ui::Event> new_event;
   rewriter.RewriteEvent(press, &new_event);
   EXPECT_TRUE(new_event);
   // Control should be remapped to Alt.
   EXPECT_EQ(ui::EF_ALT_DOWN,
             new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
 }
 
+// Keeps a buffer of handled events.
+class EventBuffer : public ui::test::TestEventProcessor {
+ public:
+  EventBuffer() {}
+  virtual ~EventBuffer() {}
+
+  void PopEvents(ScopedVector<ui::Event>* events) {
+    events->clear();
+    events->swap(events_);
+  }
+
+ private:
+  // ui::EventProcessor overrides:
+  virtual ui::EventDispatchDetails OnEventFromSource(
+      ui::Event* event) OVERRIDE {
+    if (event->IsKeyEvent()) {
+      events_.push_back(new ui::KeyEvent(*static_cast<ui::KeyEvent*>(event)));
+    } else if (event->IsMouseWheelEvent()) {
+      events_.push_back(
+          new ui::MouseWheelEvent(*static_cast<ui::MouseWheelEvent*>(event)));
+    } else if (event->IsMouseEvent()) {
+      events_.push_back(
+          new ui::MouseEvent(*static_cast<ui::MouseEvent*>(event)));
+    }
+    return ui::EventDispatchDetails();
+  }
+
+  ScopedVector<ui::Event> events_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventBuffer);
+};
+
+// Trivial EventSource that does nothing but send events.
+class TestEventSource : public ui::EventSource {
+ public:
+  explicit TestEventSource(ui::EventProcessor* processor)
+      : processor_(processor) {}
+  virtual ui::EventProcessor* GetEventProcessor() OVERRIDE {
+    return processor_;
+  }
+  ui::EventDispatchDetails Send(ui::Event* event) {
+    return SendEventToProcessor(event);
+  }
+
+ private:
+  ui::EventProcessor* processor_;
+};
+
 // Tests of event rewriting that depend on the Ash window manager.
 class EventRewriterAshTest : public ash::test::AshTestBase {
  public:
   EventRewriterAshTest()
-      : mock_user_manager_(new chromeos::MockUserManager),
+      : source_(&buffer_),
+        mock_user_manager_(new chromeos::MockUserManager),
         user_manager_enabler_(mock_user_manager_) {}
   virtual ~EventRewriterAshTest() {}
 
   bool RewriteFunctionKeys(const ui::Event& event,
                            scoped_ptr<ui::Event>* rewritten_event) {
     return rewriter_->RewriteEvent(event, rewritten_event);
   }
 
+  ui::EventDispatchDetails Send(ui::Event* event) {
+    return source_.Send(event);
+  }
+
+  void SendKeyEvent(ui::EventType type, ui::KeyboardCode key_code) {
+    ui::KeyEvent press(type, key_code, ui::EF_NONE, false);
+    ui::EventDispatchDetails details = Send(&press);
+    CHECK(!details.dispatcher_destroyed);
+  }
+
+  void SendActivateStickyKeyPattern(ui::KeyboardCode key_code) {
+    SendKeyEvent(ui::ET_KEY_PRESSED, key_code);
+    SendKeyEvent(ui::ET_KEY_RELEASED, key_code);
+  }
+
  protected:
+  TestingPrefServiceSyncable* prefs() { return &prefs_; }
+
+  void PopEvents(ScopedVector<ui::Event>* events) {
+    buffer_.PopEvents(events);
+  }
+
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
-    rewriter_.reset(new EventRewriter());
+    sticky_keys_controller_ =
+        ash::Shell::GetInstance()->sticky_keys_controller();
+    rewriter_.reset(new EventRewriter(sticky_keys_controller_));
     chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
     rewriter_->set_pref_service_for_testing(&prefs_);
+#if defined(USE_X11)
+    ui::SetUpTouchPadForTest(kTouchPadDeviceId);
+#endif
+    source_.AddEventRewriter(rewriter_.get());
+    sticky_keys_controller_->Enable(true);
   }
 
   virtual void TearDown() OVERRIDE {
     rewriter_.reset();
     AshTestBase::TearDown();
   }
 
-  TestingPrefServiceSyncable prefs_;
+ protected:
+  ash::StickyKeysController* sticky_keys_controller_;
 
  private:
   scoped_ptr<EventRewriter> rewriter_;
 
+  EventBuffer buffer_;
+  TestEventSource source_;
+
   chromeos::MockUserManager* mock_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
+  TestingPrefServiceSyncable prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
 };
 
 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
   window_state->Activate();
+  ScopedVector<ui::Event> events;
 
   // Create a simulated keypress of F1 targetted at the window.
   ui::KeyEvent press_f1(ui::ET_KEY_PRESSED, ui::VKEY_F1, 0, false);
 
   // Simulate an apps v2 window that has requested top row keys as function
   // keys. The event should not be rewritten.
   window_state->set_top_row_keys_are_function_keys(true);
-  scoped_ptr<ui::Event> rewritten_event;
-  ASSERT_FALSE(RewriteFunctionKeys(press_f1, &rewritten_event));
-  ASSERT_FALSE(rewritten_event);
+  ui::EventDispatchDetails details = Send(&press_f1);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_F1, ui::EF_NONE, ui::ET_KEY_PRESSED),
-      GetKeyEventAsString(press_f1));
+      GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0])));
 
   // The event should also not be rewritten if the send-function-keys pref is
   // additionally set, for both apps v2 and regular windows.
   BooleanPrefMember send_function_keys_pref;
-  send_function_keys_pref.Init(prefs::kLanguageSendFunctionKeys, &prefs_);
+  send_function_keys_pref.Init(prefs::kLanguageSendFunctionKeys, prefs());
   send_function_keys_pref.SetValue(true);
   window_state->set_top_row_keys_are_function_keys(false);
-  ASSERT_FALSE(RewriteFunctionKeys(press_f1, &rewritten_event));
-  ASSERT_FALSE(rewritten_event);
+  details = Send(&press_f1);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_F1, ui::EF_NONE, ui::ET_KEY_PRESSED),
-      GetKeyEventAsString(press_f1));
+      GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0])));
 
   // If the pref isn't set when an event is sent to a regular window, F1 is
   // rewritten to the back key.
   send_function_keys_pref.SetValue(false);
-  ASSERT_TRUE(RewriteFunctionKeys(press_f1, &rewritten_event));
-  ASSERT_TRUE(rewritten_event);
+  details = Send(&press_f1);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
   EXPECT_EQ(GetExpectedResultAsString(
                 ui::VKEY_BROWSER_BACK, ui::EF_NONE, ui::ET_KEY_PRESSED),
-            GetKeyEventAsString(
-                *static_cast<const ui::KeyEvent*>(rewritten_event.get())));
+            GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0])));
 }
 
 TEST_F(EventRewriterTest, TestRewrittenModifierClick) {
   std::vector<unsigned int> device_list;
   device_list.push_back(10);
   ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
 
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Check that Control + Left Button is converted (via Alt + Left Button)
   // to Right Button.
   ui::ScopedXI2Event xev;
   xev.InitGenericButtonEvent(10,
                              ui::ET_MOUSE_PRESSED,
                              gfx::Point(),
                              ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN);
   ui::MouseEvent press(xev);
   // Sanity check.
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
   EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags());
   int flags = RewriteMouseEvent(&rewriter, press);
   EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
   EXPECT_FALSE(ui::EF_CONTROL_DOWN & flags);
   EXPECT_FALSE(ui::EF_ALT_DOWN & flags);
 }
 
 
 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
+#if defined(USE_X11)
+  // TODO(kpschoedel): pending changes for crbug.com/360377
+  // to |chromeos::EventRewriter::RewriteLocatedEvent()
   std::vector<unsigned int> device_list;
   device_list.push_back(10);
   device_list.push_back(11);
   ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
   TestingPrefServiceSyncable prefs;
-  EventRewriter rewriter;
+  EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN;
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent press(xev);
     // Sanity check.
     EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
     EXPECT_EQ(kLeftAndAltFlag, press.flags());
@@ skipping 45 matching lines @@
     EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags);
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         11, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent release(xev);
     int flags = RewriteMouseEvent(&rewriter, release);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
   }
+#endif
+}
+
+TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) {
+  // Test the actual key event dispatch implementation.
+  ScopedVector<ui::Event> events;
+
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
+  EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[0])->key_code());
+
+  // Test key press event is correctly modified and modifier release
+  // event is sent.
+  ui::KeyEvent press(ui::ET_KEY_PRESSED, ui::VKEY_C, ui::EF_NONE, false);
+  ui::EventDispatchDetails details = Send(&press);
+  PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
+  EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+
+  // Test key release event is not modified.
+  ui::KeyEvent release(ui::ET_KEY_RELEASED, ui::VKEY_C, ui::EF_NONE, false);
+  details = Send(&release);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[0]->type());
+  EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
+  EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+}
+
+TEST_F(EventRewriterAshTest, MouseEventDispatchImpl) {
+  ScopedVector<ui::Event> events;
+
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  PopEvents(&events);
+
+  // Test mouse press event is correctly modified.
+  gfx::Point location(0, 0);
+  ui::MouseEvent press(ui::ET_MOUSE_PRESSED,
+                       location,
+                       location,
+                       ui::EF_LEFT_MOUSE_BUTTON,
+                       ui::EF_LEFT_MOUSE_BUTTON);
+  ui::EventDispatchDetails details = Send(&press);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(1u, events.size());
+  EXPECT_EQ(ui::ET_MOUSE_PRESSED, events[0]->type());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+
+  // Test mouse release event is correctly modified and modifier release
+  // event is sent. The mouse event should have the correct DIP location.
+  ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
+                         location,
+                         location,
+                         ui::EF_LEFT_MOUSE_BUTTON,
+                         ui::EF_LEFT_MOUSE_BUTTON);
+  details = Send(&release);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+}
+
+TEST_F(EventRewriterAshTest, MouseWheelEventDispatchImpl) {
+  ScopedVector<ui::Event> events;
+
+  // Test positive mouse wheel event is correctly modified and modifier release
+  // event is sent.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  PopEvents(&events);
+  gfx::Point location(0, 0);
+  ui::MouseEvent mev(ui::ET_MOUSEWHEEL,
+                     location,
+                     location,
+                     ui::EF_LEFT_MOUSE_BUTTON,
+                     ui::EF_LEFT_MOUSE_BUTTON);
+  ui::MouseWheelEvent positive(mev, 0, ui::MouseWheelEvent::kWheelDelta);
+  ui::EventDispatchDetails details = Send(&positive);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_TRUE(events[0]->IsMouseWheelEvent());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+
+  // Test negative mouse wheel event is correctly modified and modifier release
+  // event is sent.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  PopEvents(&events);
+  ui::MouseWheelEvent negative(mev, 0, -ui::MouseWheelEvent::kWheelDelta);
+  details = Send(&negative);
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_TRUE(events[0]->IsMouseWheelEvent());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+}
+
+class StickyKeysOverlayTest : public EventRewriterAshTest {
+ public:
+  StickyKeysOverlayTest() : overlay_(NULL) {}
+
+  virtual ~StickyKeysOverlayTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    EventRewriterAshTest::SetUp();
+    overlay_ = sticky_keys_controller_->GetOverlayForTest();
+    ASSERT_TRUE(overlay_);
+  }
+
+  ash::StickyKeysOverlay* overlay_;
+};
+
+TEST_F(StickyKeysOverlayTest, OneModifierEnabled) {
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+
+  // Pressing modifier key should show overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+
+  // Pressing a normal key should hide overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_T);
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+}
+
+TEST_F(StickyKeysOverlayTest, TwoModifiersEnabled) {
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+
+  // Pressing two modifiers should show overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_SHIFT);
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+
+  // Pressing a normal key should hide overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_N);
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+}
+
+TEST_F(StickyKeysOverlayTest, LockedModifier) {
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+
+  // Pressing a modifier key twice should lock modifier and show overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_LMENU);
+  SendActivateStickyKeyPattern(ui::VKEY_LMENU);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+
+  // Pressing a normal key should not hide overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_D);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+}
+
+TEST_F(StickyKeysOverlayTest, LockedAndNormalModifier) {
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+
+  // Pressing a modifier key twice should lock modifier and show overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+
+  // Pressing another modifier key should still show overlay.
+  SendActivateStickyKeyPattern(ui::VKEY_SHIFT);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+
+  // Pressing a normal key should not hide overlay but disable normal modifier.
+  SendActivateStickyKeyPattern(ui::VKEY_D);
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+}
+
+TEST_F(StickyKeysOverlayTest, ModifiersDisabled) {
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+
+  // Enable modifiers.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  SendActivateStickyKeyPattern(ui::VKEY_SHIFT);
+  SendActivateStickyKeyPattern(ui::VKEY_SHIFT);
+  SendActivateStickyKeyPattern(ui::VKEY_LMENU);
+
+  EXPECT_TRUE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_LOCKED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_ENABLED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+
+  // Disable modifiers and overlay should be hidden.
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
+  SendActivateStickyKeyPattern(ui::VKEY_SHIFT);
+  SendActivateStickyKeyPattern(ui::VKEY_LMENU);
+  SendActivateStickyKeyPattern(ui::VKEY_LMENU);
+
+  EXPECT_FALSE(overlay_->is_visible());
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
+  EXPECT_EQ(ash::STICKY_KEY_STATE_DISABLED,
+            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
+}
+
+TEST_F(StickyKeysOverlayTest, ModifierVisibility) {
+  // All but AltGr and Mod3 should initially be visible.
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_CONTROL_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_SHIFT_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALT_DOWN));
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
+
+  // Turn all modifiers on.
+  sticky_keys_controller_->SetModifiersEnabled(true, true);
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_CONTROL_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_SHIFT_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALT_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
+
+  // Turn off Mod3.
+  sticky_keys_controller_->SetModifiersEnabled(false, true);
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
+
+  // Turn off AltGr.
+  sticky_keys_controller_->SetModifiersEnabled(true, false);
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
+  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
+
+  // Turn off AltGr and Mod3.
+  sticky_keys_controller_->SetModifiersEnabled(false, false);
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
+  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 }
 
 }  // namespace chromeos