Sticky keys modifies an entire scroll sequence instead of just a single event.

ash/wm/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/wm/sticky_keys.h"
 
 #include <X11/Xlib.h>
 #undef None
 #undef Bool
 #undef RootWindow
@@ skipping 183 matching lines @@
     XEvent* xev = new XEvent();
     ui::InitXMouseWheelEventForTesting(wheel_delta, 0, xev);
     xevs_.push_back(xev);
     ui::MouseWheelEvent* event = new ui::MouseWheelEvent(xev);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::ScrollEvent* GenerateScrollEvent(int scroll_delta) {
-    EXPECT_FALSE(scroll_delta == 0);
     XEvent* xev = ui::CreateScrollEventForTest(
         kScrollDeviceId, // deviceid
         0,               // x_offset
         scroll_delta,    // y_offset
         0,               // x_offset_ordinal
         scroll_delta,    // y_offset_ordinal
         2);              // finger_count
     xi2_evs_.push_back(new ui::ScopedXI2Event(xev));
 
     ui::ScrollEvent* event = new ui::ScrollEvent(xev);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
+  ui::ScrollEvent* GenerateScrollFlingEvent(int fling_delta,
+                                            bool is_cancel) {
+    XEvent* xev = ui::CreateFlingEventForTest(
+        kScrollDeviceId, // deviceid
+        0,               // x_velocity
+        fling_delta,     // y_velocity
+        0,               // x_velocity_ordinal
+        fling_delta,     // y_velocity_ordinal
+        is_cancel); // is_cancel
+    ui::ScrollEvent* event = new ui::ScrollEvent(xev);
+    ui::Event::DispatcherApi dispatcher(event);
+    dispatcher.set_target(target_);
+
+    return event;
+  }
+
   // Creates a synthesized KeyEvent that is not backed by a native event.
   ui::KeyEvent* GenerateSynthesizedKeyEvent(
       bool is_key_press, ui::KeyboardCode code) {
     ui::KeyEvent* event = new ui::KeyEvent(
         is_key_press ? ui::ET_KEY_PRESSED : ui::ET_MOUSE_RELEASED,
         code, 0, true);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
@@ skipping 281 matching lines @@
   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());
 }
 
-TEST_F(StickyKeysTest, ScrollEvents) {
+TEST_F(StickyKeysTest, ScrollEventOneshot) {
   ui::SetUpScrollDeviceForTest(kScrollDeviceId);
-  // Australlian scrolling is enabled by default for some reason.
+  // 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());
-    kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
-    sticky_key.HandleKeyEvent(kev.get());
-    kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
-    sticky_key.HandleKeyEvent(kev.get());
+    SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
     EXPECT_EQ(StickyKeysHandler::ENABLED, sticky_key.current_state());
 
-    // Test scroll event is correctly modified.
-    ev.reset(GenerateScrollEvent(scroll_deltas[i]));
+    // 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(GenerateScrollFlingEvent(0, true));
+    sticky_key.HandleScrollEvent(ev.get());
+    EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN);
+    EXPECT_EQ(StickyKeysHandler::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());
+    }
+
+    // Fling start event ends scroll sequence.
+    ev.reset(GenerateScrollFlingEvent(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());
 
     ASSERT_EQ(2U, mock_delegate->GetEventCount());
-    EXPECT_EQ(ui::ET_SCROLL, mock_delegate->GetEvent(0)->type());
+    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());
+
+    // Fling cancel starts scroll sequence.
+    ev.reset(GenerateScrollFlingEvent(0, true));
+    sticky_key.HandleScrollEvent(ev.get());
+    EXPECT_EQ(StickyKeysHandler::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());
+    }
+
+    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());
+  }
+}
+
+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.
-  for (int i = 0; i < 2; ++i) {
-    kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
-    sticky_key.HandleKeyEvent(kev.get());
-    kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
-    sticky_key.HandleKeyEvent(kev.get());
-  }
+  SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
+  SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
+  EXPECT_EQ(StickyKeysHandler::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(GenerateScrollFlingEvent(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(GenerateScrollFlingEvent(-10, false));
+    sticky_key.HandleScrollEvent(ev.get());
   }
 
   EXPECT_EQ(StickyKeysHandler::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);
@@ skipping 166 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