Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(432)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ash/sticky_keys/sticky_keys_unittest.cc

Issue 137373003: Show overlay displaying the state of all sticky keys when it is enabled. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« ash/sticky_keys/sticky_keys_overlay.cc ('K') | « ash/sticky_keys/sticky_keys_overlay.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ash/sticky_keys/sticky_keys_unittest.cc
diff --git a/ash/sticky_keys/sticky_keys_unittest.cc b/ash/sticky_keys/sticky_keys_unittest.cc
index 94742478ce3c9e741671ccc60b4fc9f63b4497e7..d82cf31e71aecdb8899c1cf51ebd220bec84da65 100644
--- a/ash/sticky_keys/sticky_keys_unittest.cc
+++ b/ash/sticky_keys/sticky_keys_unittest.cc
@@ -291,13 +291,13 @@ TEST_F(StickyKeysTest, BasicOneshotScenarioTest) {
scoped_ptr<ui::KeyEvent> ev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_SHIFT, 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());
@@ -308,7 +308,7 @@ TEST_F(StickyKeysTest, BasicOneshotScenarioTest) {
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());
@@ -334,17 +334,17 @@ TEST_F(StickyKeysTest, BasicLockedScenarioTest) {
scoped_ptr<ui::KeyEvent> ev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_SHIFT, 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));
@@ -356,7 +356,7 @@ TEST_F(StickyKeysTest, BasicLockedScenarioTest) {
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());
@@ -366,53 +366,53 @@ TEST_F(StickyKeysTest, BasicLockedScenarioTest) {
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);
+ StickyKeysHandler sticky_key(STICKY_KEY_SHIFT, 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) {
@@ -420,9 +420,9 @@ TEST_F(StickyKeysTest, NormalShortcutTest) {
scoped_ptr<ui::KeyEvent> ev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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));
@@ -431,12 +431,12 @@ TEST_F(StickyKeysTest, NormalShortcutTest) {
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) {
@@ -444,9 +444,9 @@ TEST_F(StickyKeysTest, NormalModifiedClickTest) {
scoped_ptr<ui::MouseEvent> mev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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));
@@ -459,7 +459,7 @@ TEST_F(StickyKeysTest, NormalModifiedClickTest) {
// 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) {
@@ -467,9 +467,9 @@ TEST_F(StickyKeysTest, MouseMovedModifierTest) {
scoped_ptr<ui::MouseEvent> mev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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));
@@ -482,7 +482,7 @@ TEST_F(StickyKeysTest, MouseMovedModifierTest) {
// 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) {
@@ -492,9 +492,9 @@ TEST_F(StickyKeysTest, NormalModifiedScrollTest) {
scoped_ptr<ui::ScrollEvent> sev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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));
@@ -508,7 +508,7 @@ TEST_F(StickyKeysTest, NormalModifiedScrollTest) {
// 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) {
@@ -516,23 +516,23 @@ TEST_F(StickyKeysTest, MouseEventOneshot) {
scoped_ptr<ui::KeyEvent> kev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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());
@@ -557,15 +557,15 @@ TEST_F(StickyKeysTest, MouseEventLocked) {
scoped_ptr<ui::KeyEvent> kev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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) {
@@ -575,7 +575,7 @@ TEST_F(StickyKeysTest, MouseEventLocked) {
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.
@@ -585,7 +585,7 @@ TEST_F(StickyKeysTest, MouseEventLocked) {
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.
@@ -599,7 +599,7 @@ TEST_F(StickyKeysTest, MouseEventLocked) {
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) {
@@ -611,37 +611,37 @@ TEST_F(StickyKeysTest, ScrollEventOneshot) {
scoped_ptr<ui::KeyEvent> kev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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());
@@ -664,18 +664,18 @@ TEST_F(StickyKeysTest, ScrollDirectionChanged) {
scoped_ptr<ui::KeyEvent> kev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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.
@@ -683,13 +683,13 @@ TEST_F(StickyKeysTest, ScrollDirectionChanged) {
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());
}
}
@@ -702,12 +702,12 @@ TEST_F(StickyKeysTest, ScrollEventLocked) {
scoped_ptr<ui::KeyEvent> kev;
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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) {
@@ -727,26 +727,26 @@ TEST_F(StickyKeysTest, ScrollEventLocked) {
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);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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());
}
@@ -755,37 +755,37 @@ TEST_F(StickyKeysTest, SynthesizedEvents) {
// by sticky keys.
MockStickyKeysHandlerDelegate* mock_delegate =
new MockStickyKeysHandlerDelegate(this);
- StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
+ StickyKeysHandler sticky_key(STICKY_KEY_CONTROL, 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) {
« ash/sticky_keys/sticky_keys_overlay.cc ('K') | « ash/sticky_keys/sticky_keys_overlay.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698