Added multi-finger gestures to touch_exploration_controller

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 1101 matching lines @@
 // gesture is completed, enter touch exploration.
 TEST_F(TouchExplorationTest, EnterGestureInProgressState) {
   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());
   gfx::Point second_location(distance / 2, 1);
   gfx::Point third_location(distance, 1);
+  gfx::Point touch_exploration_location(20, 21);
 
   generator_->Dispatch(&first_press);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   // Since we are not out of the touch slop yet, we should not be in gesture in
   // progress.
   generator_->MoveTouch(second_location);
   EXPECT_FALSE(IsInTouchToMouseMode());
   EXPECT_FALSE(IsInGestureInProgressState());
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
 
   // Once we are out of slop, we should be in GestureInProgress.
   generator_->MoveTouch(third_location);
   EXPECT_TRUE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInTouchToMouseMode());
   const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
   ASSERT_EQ(0U, captured_events.size());
 
   // Exit out of gesture mode once grace period is over and enter touch
-  // exploration.
+  // exploration. There should be a move when entering touch exploration and
+  // also for the touch move.
   AdvanceSimulatedTimePastTapDelay();
-  ASSERT_EQ(1U, captured_events.size());
+  generator_->MoveTouch(touch_exploration_location);
+  ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
+  EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
   EXPECT_TRUE(IsInTouchToMouseMode());
   EXPECT_FALSE(IsInGestureInProgressState());
 }
 
 // A swipe+direction gesture should trigger a Shift+Search+Direction
 // keyboard event.
 TEST_F(TouchExplorationTest, GestureSwipe) {
   SwitchTouchExplorationMode(true);
   std::vector<ui::KeyboardCode> directions;
   directions.push_back(ui::VKEY_RIGHT);
   directions.push_back(ui::VKEY_LEFT);
   directions.push_back(ui::VKEY_UP);
   directions.push_back(ui::VKEY_DOWN);
 
-  for (std::vector<ui::KeyboardCode>::const_iterator it = directions.begin();
-       it != directions.end();
-       ++it) {
-    int x = 30;
-    int y = 31;
-    ui::TouchEvent origin(ui::ET_TOUCH_PRESSED, gfx::Point(x, y), 0, Now());
-    generator_->Dispatch(&origin);
+  // This value was taken from gesture_recognizer_unittest.cc in a swipe
+  // detector test, since it seems to be about the right amount to get a swipe.
+  const int kSteps = 15;
 
-    ui::KeyboardCode direction = *it;
-    float distance = gesture_detector_config_.touch_slop + 1;
-    scoped_ptr<gfx::Point> swipe;
-    switch (direction) {
-      case ui::VKEY_RIGHT:
-        swipe.reset(new gfx::Point(x + distance, y));
-        break;
-      case ui::VKEY_LEFT:
-        swipe.reset(new gfx::Point(x - distance, y));
-        break;
-      case ui::VKEY_UP:
-        swipe.reset(new gfx::Point(x, y - distance));
-        break;
-      case ui::VKEY_DOWN:
-        swipe.reset(new gfx::Point(x, y + distance));
-        break;
-      default:
-        return;
+  // There are gestures supported with up to four fingers.
+  for (int num_fingers = 1; num_fingers <= 4; num_fingers++) {
+    std::vector<gfx::Point> start_points;
+    for(int j = 0; j < num_fingers; j++){
+      start_points.push_back(gfx::Point(j * 10 + 100, j * 10 + 200));
     }
+    gfx::Point* start_points_array = &start_points[0];
+    const float distance = gesture_detector_config_.touch_slop + 1;
+    // Iterate through each swipe direction for this number of fingers.
+    for (std::vector<ui::KeyboardCode>::const_iterator it = directions.begin();
+         it != directions.end();
+         ++it) {
+      int move_x = 0;
+      int move_y = 0;
+      ui::KeyboardCode direction = *it;
+      switch (direction) {
+        case ui::VKEY_RIGHT:
+          move_x = distance;
+          break;
+        case ui::VKEY_LEFT:
+          move_x = 0 - distance;
+          break;
+        case ui::VKEY_UP:
+          move_y = 0 - distance;
+          break;
+        case ui::VKEY_DOWN:
+          move_y = distance;
+          break;
+        default:
+          return;
+      }
 
-    // A swipe is made when a fling starts
-    float delta_time =
-        distance / gesture_detector_config_.maximum_fling_velocity;
-    simulated_clock_->Advance(base::TimeDelta::FromSecondsD(delta_time));
-    generator_->MoveTouch(*swipe);
-    EXPECT_TRUE(IsInGestureInProgressState());
-    EXPECT_FALSE(IsInTouchToMouseMode());
-    const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
-    ASSERT_EQ(0U, captured_events.size());
-    generator_->ReleaseTouch();
+      // A swipe is made when a fling starts
+      float delta_time =
+          distance / gesture_detector_config_.maximum_fling_velocity;
+      // delta_time is in seconds, so we convert to ms.
+      int delta_time_ms = floor(delta_time * 1000);
+      generator_->GestureMultiFingerScroll(num_fingers,
+                                           start_points_array,
+                                           delta_time_ms,
+                                           kSteps,
+                                           move_x * 2,
+                                           move_y * 2);
 
-    // The swipe registered and sent the appropriate key events.
-    AssertDirectionalNavigationEvents(captured_events, direction);
-    EXPECT_TRUE(IsInNoFingersDownState());
-    EXPECT_FALSE(IsInTouchToMouseMode());
-    EXPECT_FALSE(IsInGestureInProgressState());
-    ClearCapturedEvents();
+      // The swipe registered and sent the appropriate key events.
+      const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+      if (num_fingers == 1)
+        AssertDirectionalNavigationEvents(captured_events, direction);
+      else {
+        // Most of the time this is 2 right now, but two of the two finger
+        // swipes are mapped to chromevox commands which dispatch 6 key events,
+        // and these will probably be remapped a lot as we're developing.
+        ASSERT_GE(captured_events.size(), 2U);
+        std::vector<ui::Event>::size_type i;
+        for (i = 0; i != captured_events.size(); i++) {
+          EXPECT_TRUE(captured_events[i]->IsKeyEvent());
+        }
+      }
+      EXPECT_TRUE(IsInNoFingersDownState());
+      EXPECT_FALSE(IsInTouchToMouseMode());
+      EXPECT_FALSE(IsInGestureInProgressState());
+      ClearCapturedEvents();
+    }
   }
 }
 
-// Since there are so many permutations, this test is too slow in debug
-// mode, so it will only be run in release mode.
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-#define MAYBE_AllFingerPermutations AllFingerPermutations
-#else
-#define MAYBE_AllFingerPermutations DISABLED_AllFingerPermutations
-#endif
+// Since there are so many permutations, this test is fairly slow. Therefore, it
+// is disabled and will be turned on to check during development.
 
-TEST_F(TouchExplorationTest, MAYBE_AllFingerPermutations) {
+TEST_F(TouchExplorationTest, DISABLED_AllFingerPermutations) {
   SwitchTouchExplorationMode(true);
   SuppressVLOGs(true);
   // We will test all permutations of events from three different fingers
   // to ensure that we return to NO_FINGERS_DOWN when fingers have been
   // released.
   ScopedVector<ui::TouchEvent> all_events;
   for (int touch_id = 0; touch_id < 3; touch_id++){
     int x = 10*touch_id + 1;
     int y = 10*touch_id + 2;
     all_events.push_back(new TouchEvent(
@@ skipping 88 matching lines @@
         generator_->ReleaseTouchId(j);
         fingers_pressed[j] = false;
       }
     }
     AdvanceSimulatedTimePastPotentialTapDelay();
     EXPECT_TRUE(IsInNoFingersDownState());
     ClearCapturedEvents();
   }
 }
 
-// With the simple swipe gestures, if additional fingers are added, then the
-// state should change to the wait for one finger state.
+// With the simple swipe gestures, if additional fingers are added and the tap
+// timer times out, then the state should change to the wait for one finger
+// state.
 TEST_F(TouchExplorationTest, GestureAddedFinger) {
   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(100, 200), 0, Now());
   generator_->Dispatch(&first_press);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   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 prevent gestures from continuing to
-  // go through.
+  // Generate a second press, but time out past the gesture period so that
+  // gestures are prevented from continuing to go through.
   ui::TouchEvent second_press(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 21), 1, Now());
   generator_->Dispatch(&second_press);
+  AdvanceSimulatedTimePastTapDelay();
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInTouchToMouseMode());
   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);
+  gfx::Point fourth_location(window_right, 35);
 
   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());
+
+  // Now that we are in slide gesture, we can adjust the volume.
+  generator_->MoveTouch(fourth_location);
   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).
+  // elapsed, there should have been a sound that fired and a volume
+  // change.
   size_t num_adjust_sounds = delegate_.NumAdjustSounds();
-  ASSERT_EQ(2U, num_adjust_sounds);
-  ASSERT_EQ(2U, delegate_.VolumeChanges().size());
+  ASSERT_EQ(1U, num_adjust_sounds);
+  ASSERT_EQ(1U, 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());
@@ skipping 41 matching lines @@
 // 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);
+
+  gfx::Point center_screen(window.right() / 2, window.bottom() / 2);
+
   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);
+  generator_->Dispatch(&first_press);
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+
+  // Move past the touch slop to begin slide gestures.
+  // + slop + 1 to actually leave slop.
+  gfx::Point touch_move(
+      initial_press.x(),
+      initial_press.y() + gesture_detector_config_.touch_slop + 1);
+  generator_->MoveTouch(touch_move);
+  EXPECT_FALSE(IsInGestureInProgressState());
+  EXPECT_TRUE(IsInSlideGestureState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  // Move the touch into slop boundaries. It should still be in slide gestures
+  // and adjust the volume.
   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());
+  ASSERT_EQ(1U, num_adjust_sounds);
+  ASSERT_EQ(1U, 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());
+  ASSERT_EQ(1U, num_adjust_sounds);
+  ASSERT_EQ(1U, delegate_.VolumeChanges().size());
 
   // Move the touch back into slop edge distance and volume should be changing
-  // again.
+  // again, one volume change for each new move.
   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(2U, 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.
@@ skipping 16 matching lines @@
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInSlideGestureState());
   EXPECT_TRUE(IsInTouchToMouseMode());
 }
 
 // If two fingers tap the screen at the same time and release before the tap
 // timer runs out, a control key event should be sent to silence chromevox.
 TEST_F(TouchExplorationTest, TwoFingerTap) {
   SwitchTouchExplorationMode(true);
 
+  generator_->set_current_location(gfx::Point(101, 102));
   generator_->PressTouchId(1);
   EXPECT_FALSE(IsInTwoFingerTapState());
 
   generator_->PressTouchId(2);
   EXPECT_TRUE(IsInTwoFingerTapState());
 
   const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
   ASSERT_EQ(0U, captured_events.size());
 
   generator_->ReleaseTouchId(1);
+  EXPECT_TRUE(IsInTwoFingerTapState());
   generator_->ReleaseTouchId(2);
 
   // Two key events should have been sent to silence the feedback.
   EXPECT_EQ(2U, captured_events.size());
 }
 
 // If the fingers are not released before the tap timer runs out, a control
 // keyevent is not sent and the state will no longer be in two finger tap.
 TEST_F(TouchExplorationTest, TwoFingerTapAndHold) {
   SwitchTouchExplorationMode(true);
@@ skipping 89 matching lines @@
   EXPECT_TRUE(IsInTwoFingerTapState());
 
   const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
   ASSERT_EQ(0U, captured_events.size());
 
   generator_->Dispatch(&out_slop_id_2);
   EXPECT_FALSE(IsInTwoFingerTapState());
 }
 
 }  // namespace ui