Show overlay displaying the state of all sticky keys when it is enabled.

ash/sticky_keys/sticky_keys_unittest.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #include <X11/Xlib.h>
 #undef None
 #undef Bool
 #undef RootWindow
@@ skipping 275 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysTest);
 };
 
 TEST_F(StickyKeysTest, BasicOneshotScenarioTest) {
   scoped_ptr<ui::KeyEvent> ev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // By typing Shift key, internal state become ENABLED.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   ev.reset(GenerateKey(true, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
 
   // Next keyboard event is shift modified.
   EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN);
 
   ev.reset(GenerateKey(false, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   // Making sure Shift up keyboard event is dispatched.
   ASSERT_EQ(2U, mock_delegate->GetEventCount());
   EXPECT_EQ(ui::ET_KEY_PRESSED, mock_delegate->GetEvent(0)->type());
   EXPECT_EQ(ui::VKEY_A,
             static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(0))
                 ->key_code());
   EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type());
   EXPECT_EQ(ui::VKEY_SHIFT,
             static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1))
                 ->key_code());
 
   // Enabled state is one shot, so next key event should not be shift modified.
   ev.reset(GenerateKey(true, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_FALSE(ev->flags() & ui::EF_SHIFT_DOWN);
 
   ev.reset(GenerateKey(false, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_FALSE(ev->flags() & ui::EF_SHIFT_DOWN);
 }
 
 TEST_F(StickyKeysTest, BasicLockedScenarioTest) {
   scoped_ptr<ui::KeyEvent> ev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // By typing shift key, internal state become ENABLED.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   // By typing shift key again, internal state become LOCKED.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // All keyboard events including keyUp become shift modified.
   ev.reset(GenerateKey(true, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN);
 
   ev.reset(GenerateKey(false, ui::VKEY_A));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN);
 
   // Locked state keeps after normal keyboard event.
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   ev.reset(GenerateKey(true, ui::VKEY_B));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN);
 
   ev.reset(GenerateKey(false, ui::VKEY_B));
   sticky_key.HandleKeyEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN);
 
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // By typing shift key again, internal state become back to DISABLED.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, NonTargetModifierTest) {
   scoped_ptr<ui::KeyEvent> ev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Non target modifier key does not affect internal state
   ev.reset(GenerateKey(true, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   ev.reset(GenerateKey(false, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   // Non target modifier key does not affect internal state
   ev.reset(GenerateKey(true, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   ev.reset(GenerateKey(false, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT);
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // Non target modifier key does not affect internal state
   ev.reset(GenerateKey(true, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   ev.reset(GenerateKey(false, ui::VKEY_MENU));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, NormalShortcutTest) {
   // Sticky keys should not be enabled if we perform a normal shortcut.
   scoped_ptr<ui::KeyEvent> ev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Perform ctrl+n shortcut.
   ev.reset(GenerateKey(true, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(ev.get());
   ev.reset(GenerateKey(true, ui::VKEY_N));
   sticky_key.HandleKeyEvent(ev.get());
   ev.reset(GenerateKey(false, ui::VKEY_N));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Sticky keys should not be enabled afterwards.
   ev.reset(GenerateKey(false, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, NormalModifiedClickTest) {
   scoped_ptr<ui::KeyEvent> kev;
   scoped_ptr<ui::MouseEvent> mev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Perform ctrl+click.
   kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
   mev.reset(GenerateMouseEvent(true));
   sticky_key.HandleMouseEvent(mev.get());
   mev.reset(GenerateMouseEvent(false));
   sticky_key.HandleMouseEvent(mev.get());
 
   // Sticky keys should not be enabled afterwards.
   kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, MouseMovedModifierTest) {
   scoped_ptr<ui::KeyEvent> kev;
   scoped_ptr<ui::MouseEvent> mev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Press ctrl and handle mouse move events.
   kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
   mev.reset(GenerateSynthesizedMouseEvent(0, 0));
   sticky_key.HandleMouseEvent(mev.get());
   mev.reset(GenerateSynthesizedMouseEvent(100, 100));
   sticky_key.HandleMouseEvent(mev.get());
 
   // Sticky keys should be enabled afterwards.
   kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, NormalModifiedScrollTest) {
   ui::SetUpScrollDeviceForTest(kScrollDeviceId);
 
   scoped_ptr<ui::KeyEvent> kev;
   scoped_ptr<ui::ScrollEvent> sev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Perform ctrl+scroll.
   kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
   sev.reset(GenerateFlingScrollEvent(0, true));
   sticky_key.HandleScrollEvent(sev.get());
   sev.reset(GenerateScrollEvent(10));
   sticky_key.HandleScrollEvent(sev.get());
   sev.reset(GenerateFlingScrollEvent(10, false));
   sticky_key.HandleScrollEvent(sev.get());
 
   // Sticky keys should not be enabled afterwards.
   kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, MouseEventOneshot) {
   scoped_ptr<ui::MouseEvent> ev;
   scoped_ptr<ui::KeyEvent> kev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   // We should still be in the ENABLED state until we get the mouse
   // release event.
   ev.reset(GenerateMouseEvent(true));
   sticky_key.HandleMouseEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   ev.reset(GenerateMouseEvent(false));
   sticky_key.HandleMouseEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Making sure modifier key release event is dispatched in the right order.
   ASSERT_EQ(2u, mock_delegate->GetEventCount());
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, mock_delegate->GetEvent(0)->type());
   EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type());
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1))
                 ->key_code());
 
   // Enabled state is one shot, so next click should not be control modified.
   ev.reset(GenerateMouseEvent(true));
   sticky_key.HandleMouseEvent(ev.get());
   EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN);
 
   ev.reset(GenerateMouseEvent(false));
   sticky_key.HandleMouseEvent(ev.get());
   EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN);
 }
 
 TEST_F(StickyKeysTest, MouseEventLocked) {
   scoped_ptr<ui::MouseEvent> ev;
   scoped_ptr<ui::KeyEvent> kev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Pressing modifier key twice should make us enter lock state.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // Mouse events should not disable locked mode.
   for (int i = 0; i < 3; ++i) {
     ev.reset(GenerateMouseEvent(true));
     sticky_key.HandleMouseEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
     ev.reset(GenerateMouseEvent(false));
     sticky_key.HandleMouseEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-    EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
   }
 
   // Test with mouse wheel.
   for (int i = 0; i < 3; ++i) {
     ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta));
     sticky_key.HandleMouseEvent(ev.get());
     ev.reset(GenerateMouseWheelEvent(-ui::MouseWheelEvent::kWheelDelta));
     sticky_key.HandleMouseEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-    EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
   }
 
   // Test mixed case with mouse events and key events.
   ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta));
   sticky_key.HandleMouseEvent(ev.get());
   EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
   kev.reset(GenerateKey(true, ui::VKEY_N));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN);
   kev.reset(GenerateKey(false, ui::VKEY_N));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN);
 
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, ScrollEventOneshot) {
   ui::SetUpScrollDeviceForTest(kScrollDeviceId);
   // Disable Australlian scrolling.
   ui::DeviceDataManager::GetInstance()->set_natural_scroll_enabled(true);
 
   scoped_ptr<ui::ScrollEvent> ev;
   scoped_ptr<ui::KeyEvent> kev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   int scroll_deltas[] = {-10, 10};
   for (int i = 0; i < 2; ++i) {
     mock_delegate->ClearEvents();
 
     // Enable sticky keys.
-    EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
     SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-    EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Test a scroll sequence. Sticky keys should only be disabled at the end
     // of the scroll sequence. Fling cancel event starts the scroll sequence.
     ev.reset(GenerateFlingScrollEvent(0, true));
     sticky_key.HandleScrollEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-    EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Scrolls should all be modified but not disable sticky keys.
     for (int j = 0; j < 3; ++j) {
       ev.reset(GenerateScrollEvent(scroll_deltas[i]));
       sticky_key.HandleScrollEvent(ev.get());
       EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-      EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+      EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
     }
 
     // Fling start event ends scroll sequence.
     ev.reset(GenerateFlingScrollEvent(scroll_deltas[i], false));
     sticky_key.HandleScrollEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-    EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
     ASSERT_EQ(2U, mock_delegate->GetEventCount());
     EXPECT_EQ(ui::ET_SCROLL_FLING_START, mock_delegate->GetEvent(0)->type());
     EXPECT_FLOAT_EQ(scroll_deltas[i],
                     static_cast<const ui::ScrollEvent*>(
                         mock_delegate->GetEvent(0))->y_offset());
     EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type());
     EXPECT_EQ(ui::VKEY_CONTROL,
               static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1))
                   ->key_code());
   }
 }
 
 TEST_F(StickyKeysTest, ScrollDirectionChanged) {
   ui::SetUpScrollDeviceForTest(kScrollDeviceId);
   // Disable Australlian scrolling.
   ui::DeviceDataManager::GetInstance()->set_natural_scroll_enabled(true);
 
   scoped_ptr<ui::ScrollEvent> ev;
   scoped_ptr<ui::KeyEvent> kev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   // Test direction change with both boundary value and negative value.
   const int direction_change_values[2] = {0, -10};
   for (int i = 0; i < 2; ++i) {
     SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-    EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Fling cancel starts scroll sequence.
     ev.reset(GenerateFlingScrollEvent(0, true));
     sticky_key.HandleScrollEvent(ev.get());
-    EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Test that changing directions in a scroll sequence will
     // return sticky keys to DISABLED state.
     for (int j = 0; j < 3; ++j) {
       ev.reset(GenerateScrollEvent(10));
       sticky_key.HandleScrollEvent(ev.get());
       EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
-      EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+      EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
     }
 
     ev.reset(GenerateScrollEvent(direction_change_values[i]));
     sticky_key.HandleScrollEvent(ev.get());
     EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN);
-    EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+    EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   }
 }
 
 TEST_F(StickyKeysTest, ScrollEventLocked) {
   ui::SetUpScrollDeviceForTest(kScrollDeviceId);
   // Disable Australlian scrolling.
   ui::DeviceDataManager::GetInstance()->set_natural_scroll_enabled(true);
 
   scoped_ptr<ui::ScrollEvent> ev;
   scoped_ptr<ui::KeyEvent> kev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   // Lock sticky keys.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // Test scroll events are correctly modified in locked state.
   for (int i = 0; i < 5; ++i) {
     // Fling cancel starts scroll sequence.
     ev.reset(GenerateFlingScrollEvent(0, true));
     sticky_key.HandleScrollEvent(ev.get());
 
     ev.reset(GenerateScrollEvent(10));
     sticky_key.HandleScrollEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
     ev.reset(GenerateScrollEvent(-10));
     sticky_key.HandleScrollEvent(ev.get());
     EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
 
     // Fling start ends scroll sequence.
     ev.reset(GenerateFlingScrollEvent(-10, false));
     sticky_key.HandleScrollEvent(ev.get());
   }
 
-  EXPECT_EQ(StickyKeysHandler::LOCKED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, EventTargetDestroyed) {
   scoped_ptr<ui::KeyEvent> ev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   target()->Focus();
 
   // Go into ENABLED state.
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   // CTRL+J is a special shortcut that will destroy the event target.
   ev.reset(GenerateKey(true, ui::VKEY_J));
   sticky_key.HandleKeyEvent(ev.get());
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   EXPECT_FALSE(target());
 }
 
 TEST_F(StickyKeysTest, SynthesizedEvents) {
   // Non-native, internally generated events should be properly handled
   // by sticky keys.
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   // Test non-native key events.
   scoped_ptr<ui::KeyEvent> kev;
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   kev.reset(GenerateSynthesizedKeyEvent(true, ui::VKEY_K));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   kev.reset(GenerateSynthesizedKeyEvent(false, ui::VKEY_K));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_FALSE(kev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Test non-native mouse events.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   scoped_ptr<ui::MouseEvent> mev;
   mev.reset(GenerateSynthesizedMouseEvent(true));
   sticky_key.HandleMouseEvent(mev.get());
   EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   mev.reset(GenerateSynthesizedMouseEvent(false));
   sticky_key.HandleMouseEvent(mev.get());
   EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN);
-  EXPECT_EQ(StickyKeysHandler::DISABLED, sticky_key.current_state());
+  EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, KeyEventDispatchImpl) {
   // Test the actual key event dispatch implementation.
   EventBuffer buffer;
   ScopedVector<ui::Event> events;
   aura::WindowTreeHostDelegate* delegate = Shell::GetPrimaryRootWindow()
       ->GetDispatcher()->AsWindowTreeHostDelegate();
   Shell::GetInstance()->AddPreTargetHandler(&buffer);
   Shell::GetInstance()->sticky_keys_controller()->Enable(true);
@@ skipping 105 matching lines @@
             static_cast<ui::MouseWheelEvent*>(events[0])->y_offset());
   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());
 
   Shell::GetInstance()->RemovePreTargetHandler(&buffer);
 }
 
 }  // namespace ash