Side Slide Gestures for Accessibility

ui/chromeos/touch_exploration_controller_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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 54 matching lines @@
 };
 
 int Factorial(int n) {
   if (n <= 0)
     return 0;
   if (n == 1)
     return 1;
   return n * Factorial(n - 1);
 }
 
+class MockTouchExplorationControllerDelegate
+    : public ui::TouchExplorationControllerDelegate {
+ public:
+  virtual void PlayVolumeAdjustSound() OVERRIDE {
+    ++num_times_adjust_sound_played_;
+  }
+  virtual void SetOutputLevel(int volume) OVERRIDE {
+    volume_changes_.push_back(volume);
+  }
+
+  const std::vector<float> VolumeChanges() { return volume_changes_; }
+  const size_t NumAdjustSounds() { return num_times_adjust_sound_played_; }
+
+ private:
+  std::vector<float> volume_changes_;
+  size_t num_times_adjust_sound_played_ = 0;
+};
+
 }  // namespace
 
 class TouchExplorationControllerTestApi {
  public:
   TouchExplorationControllerTestApi(
       TouchExplorationController* touch_exploration_controller) {
     touch_exploration_controller_.reset(touch_exploration_controller);
   }
 
   void CallTapTimerNowForTesting() {
@@ skipping 18 matching lines @@
   bool IsInNoFingersDownStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->NO_FINGERS_DOWN;
   }
 
   bool IsInGestureInProgressStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->GESTURE_IN_PROGRESS;
   }
 
+  bool IsInSlideGestureStateForTesting() const {
+    return touch_exploration_controller_->state_ ==
+           touch_exploration_controller_->SLIDE_GESTURE;
+  }
+
+  gfx::Rect BoundsOfRootWindowInDIPForTesting() const {
+    return touch_exploration_controller_->root_window_->GetBoundsInScreen();
+  }
+
   // VLOGs should be suppressed in tests that generate a lot of logs,
   // for example permutations of nine touch events.
   void SuppressVLOGsForTesting(bool suppress) {
     touch_exploration_controller_->VLOG_on_ = !suppress;
   }
 
+  float GetMaxDistanceFromEdge() const {
+    return touch_exploration_controller_->kMaxDistanceFromEdge;
+  }
+
+  float GetSlopDistanceFromEdge() const {
+    return touch_exploration_controller_->kSlopDistanceFromEdge;
+  }
+
  private:
   scoped_ptr<TouchExplorationController> touch_exploration_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
 };
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
     // Tests fail if time is ever 0.
@@ skipping 76 matching lines @@
   }
 
   void SuppressVLOGs(bool suppress) {
     touch_exploration_controller_->SuppressVLOGsForTesting(suppress);
   }
 
   void SwitchTouchExplorationMode(bool on) {
     if (!on && touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset();
     } else if (on && !touch_exploration_controller_.get()) {
-      touch_exploration_controller_.reset(new TouchExplorationControllerTestApi(
-          new ui::TouchExplorationController(root_window())));
+      touch_exploration_controller_.reset(
+          new ui::TouchExplorationControllerTestApi(
+              new TouchExplorationController(root_window(), &delegate_)));
       touch_exploration_controller_->SetEventHandlerForTesting(
           &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
     }
   }
 
   void EnterTouchExplorationModeAtLocation(gfx::Point tap_location) {
     ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED, tap_location, 0, Now());
     generator_->Dispatch(&touch_press);
@@ skipping 22 matching lines @@
 
   bool IsInNoFingersDownState() {
     return touch_exploration_controller_->IsInNoFingersDownStateForTesting();
   }
 
   bool IsInGestureInProgressState() {
     return touch_exploration_controller_
         ->IsInGestureInProgressStateForTesting();
   }
 
+  bool IsInSlideGestureState() {
+    return touch_exploration_controller_->IsInSlideGestureStateForTesting();
+  }
+
+  gfx::Rect BoundsOfRootWindowInDIP() {
+    return touch_exploration_controller_->BoundsOfRootWindowInDIPForTesting();
+  }
+
+  float GetMaxDistanceFromEdge() const{
+    return touch_exploration_controller_->GetMaxDistanceFromEdge();
+  }
+
+  float GetSlopDistanceFromEdge() const{
+    return touch_exploration_controller_->GetSlopDistanceFromEdge();
+  }
+
   base::TimeDelta Now() {
     // This is the same as what EventTimeForNow() does, but here we do it
     // with our simulated clock.
     return base::TimeDelta::FromInternalValue(
         simulated_clock_->NowTicks().ToInternalValue());
   }
 
   scoped_ptr<aura::test::EventGenerator> generator_;
   ui::GestureDetector::Config gesture_detector_config_;
   // Owned by |generator_|.
   base::SimpleTestTickClock* simulated_clock_;
+  MockTouchExplorationControllerDelegate delegate_;
 
  private:
   EventCapturer event_capturer_;
   scoped_ptr<TouchExplorationControllerTestApi>
       touch_exploration_controller_;
   scoped_ptr<aura::test::TestCursorClient> cursor_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
 };
 
@@ skipping 222 matching lines @@
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // If an event is received after the double-tap timeout has elapsed, but
 // before the timer has fired, a mouse move should still be generated.
 TEST_F(TouchExplorationTest, TimerFiresLateDuringTouchExploration) {
   SwitchTouchExplorationMode(true);
 
+  // Make sure the touch is not in a corner of the screen.
+  generator_->MoveTouch(gfx::Point(100, 200));
+
   // Send a press, then add another finger after the double-tap timeout.
   generator_->PressTouchId(1);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
   generator_->PressTouchId(2);
   std::vector<ui::LocatedEvent*> events =
       GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
 
@@ skipping 828 matching lines @@
 }
 
 // With the simple swipe gestures, if additional fingers are added, then the
 // state should change to passthrough.
 TEST_F(TouchExplorationTest, FromGestureToPassthrough) {
   SwitchTouchExplorationMode(true);
   EXPECT_FALSE(IsInTouchToMouseMode());
   EXPECT_FALSE(IsInGestureInProgressState());
 
   float distance = gesture_detector_config_.touch_slop + 1;
-  ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 1), 0, Now());
+  ui::TouchEvent first_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 0, Now());
   generator_->Dispatch(&first_press);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
-  gfx::Point second_location(distance, 1);
+  gfx::Point second_location(100 + distance, 200);
   generator_->MoveTouch(second_location);
   EXPECT_TRUE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInTouchToMouseMode());
   const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
   ASSERT_EQ(0U, captured_events.size());
 
   // Generate a second press that should go through as is.
   ui::TouchEvent second_press(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 21), 1, Now());
   generator_->Dispatch(&second_press);
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInTouchToMouseMode());
   std::vector<ui::LocatedEvent*> captured_located_events =
       GetCapturedLocatedEvents();
   ASSERT_EQ(1U, captured_events.size());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_located_events[0], &second_press);
   ClearCapturedEvents();
 
   // The rest of the events should occur in passthrough.
   generator_->ReleaseTouchId(0);
   ASSERT_EQ(1U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
   ClearCapturedEvents();
   generator_->ReleaseTouchId(1);
   ASSERT_EQ(0U, captured_events.size());
 }
 
+TEST_F(TouchExplorationTest, EnterSlideGestureState) {
+  SwitchTouchExplorationMode(true);
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+
+  int window_right = BoundsOfRootWindowInDIP().right();
+  float distance = gesture_detector_config_.touch_slop + 1;
+  ui::TouchEvent first_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(window_right, 1), 0, Now());
+  gfx::Point second_location(window_right, 1 + distance / 2);
+  gfx::Point third_location(window_right, 1 + distance);
+
+  generator_->Dispatch(&first_press);
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  // Since we haven't moved past slop yet, we should not be in slide gesture.
+  generator_->MoveTouch(second_location);
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  // Once we are out of slop, we should be in slide gesture since we are along
+  // the edge of the screen.
+  generator_->MoveTouch(third_location);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  // Since we are at the right edge of the screen, but the sound timer has not
+  // elapsed, there should have two sounds that fired and two volume
+  // changes (one for each movement).
+  size_t num_adjust_sounds = delegate_.NumAdjustSounds();
+  ASSERT_EQ(2U, num_adjust_sounds);
+  ASSERT_EQ(2U, delegate_.VolumeChanges().size());
+
+  // Exit out of slide gesture once touch is lifted, but not before even if the
+  // grace period is over.
+
+  AdvanceSimulatedTimePastPotentialTapDelay();
+  ASSERT_EQ(0U, captured_events.size());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+
+  generator_->ReleaseTouch();
+  ASSERT_EQ(0U, captured_events.size());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+}
+
+// If a press + move occurred outside the boundaries, but within the slop
+// boundaries and then moved into the boundaries of an edge, there still should
+// not be a slide gesture.
+TEST_F(TouchExplorationTest, AvoidEnteringSlideGesture) {
+  SwitchTouchExplorationMode(true);
+
+  gfx::Rect window = BoundsOfRootWindowInDIP();
+  float distance = gesture_detector_config_.touch_slop + 1;
+  ui::TouchEvent first_press(
+      ui::ET_TOUCH_PRESSED,
+      gfx::Point(window.right() - GetSlopDistanceFromEdge(), 1),
+      0,
+      Now());
+  gfx::Point out_of_slop(window.right() - GetSlopDistanceFromEdge() + distance,
+                         1);
+  gfx::Point into_boundaries(window.right() - GetMaxDistanceFromEdge() / 2, 1);
+
+  generator_->Dispatch(&first_press);
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  generator_->MoveTouch(out_of_slop);
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_TRUE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  // Since we did not start moving while in the boundaries, we should not be in
+  // slide gestures.
+  generator_->MoveTouch(into_boundaries);
+  EXPECT_TRUE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->ReleaseTouch();
+}
+
+// If the slide gesture begins within the boundaries and then moves
+// SlopDistanceFromEdge there should still be a sound change. If the finger
+// moves into the center screen, there should no longer be a sound change but it
+// should still be in slide gesture. If the finger moves back into the edges
+// without lifting, it should start changing sound again.
+TEST_F(TouchExplorationTest, TestingBoundaries) {
+  SwitchTouchExplorationMode(true);
+
+  gfx::Rect window = BoundsOfRootWindowInDIP();
+  gfx::Point initial_press(window.right() - GetMaxDistanceFromEdge() / 2, 1);
+  ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, initial_press, 0, Now());
+  gfx::Point touch_move(initial_press.x() + gesture_detector_config_.touch_slop,
+                        1);
+  gfx::Point into_slop_boundaries(
+      window.right() - GetSlopDistanceFromEdge() / 2, 1);
+  gfx::Point center_screen(window.right() / 2, window.bottom() / 2);
+
+  generator_->Dispatch(&first_press);
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  generator_->MoveTouch(touch_move);
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  // Move the touch into slop boundaries. It should stil be in slide gestures
+  // and adjust the volume.
+  generator_->MoveTouch(into_slop_boundaries);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+
+  // The sound is rate limiting so it only activates every 150ms.
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
+
+  size_t num_adjust_sounds = delegate_.NumAdjustSounds();
+  ASSERT_EQ(2U, num_adjust_sounds);
+  ASSERT_EQ(2U, delegate_.VolumeChanges().size());
+
+  // Move the touch into the center of the window. It should still be in slide
+  // gestures, but there should not be anymore volume adjustments.
+  generator_->MoveTouch(center_screen);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
+  num_adjust_sounds = delegate_.NumAdjustSounds();
+  ASSERT_EQ(2U, num_adjust_sounds);
+  ASSERT_EQ(2U, delegate_.VolumeChanges().size());
+
+  // Move the touch back into slop edge distance and volume should be changing
+  // again.
+  generator_->MoveTouch(into_slop_boundaries);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+
+  generator_->MoveTouch(
+      gfx::Point(into_slop_boundaries.x() + gesture_detector_config_.touch_slop,
+                 into_slop_boundaries.y()));
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
+
+  num_adjust_sounds = delegate_.NumAdjustSounds();
+  ASSERT_EQ(3U, num_adjust_sounds);
+  ASSERT_EQ(3U, delegate_.VolumeChanges().size());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->ReleaseTouch();
+}
+
+// Even if the gesture starts within bounds, if it has not moved past slop
+// within the grace period, it should go to touch exploration.
+TEST_F(TouchExplorationTest, InBoundariesTouchExploration) {
+  SwitchTouchExplorationMode(true);
+
+  gfx::Rect window = BoundsOfRootWindowInDIP();
+  gfx::Point initial_press(window.right() - GetMaxDistanceFromEdge() / 2, 1);
+  ui::TouchEvent first_press(
+      ui::ET_TOUCH_PRESSED,
+      initial_press,
+      0,
+      Now());
+  generator_->Dispatch(&first_press);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+
+  AdvanceSimulatedTimePastTapDelay();
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  EXPECT_TRUE(IsInTouchToMouseMode());
+}
+
 }  // namespace ui