Revert of Swipe Gestures for Accessibility

ui/chromeos/touch_exploration_controller.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/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 
 #define VLOG_STATE() if (VLOG_IS_ON(0)) VlogState(__func__)
 #define VLOG_EVENT(event) if (VLOG_IS_ON(0)) VlogEvent(event, __func__)
 
 namespace ui {
 
-namespace {
-// In ChromeOS, VKEY_LWIN is synonymous for the search key.
-const ui::KeyboardCode kChromeOSSearchKey = ui::VKEY_LWIN;
-}  // namespace
-
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window)
     : root_window_(root_window),
       state_(NO_FINGERS_DOWN),
       event_handler_for_testing_(NULL),
-      gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN) {
   CHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 void TouchExplorationController::CallTapTimerNowForTesting() {
   DCHECK(tap_timer_.IsRunning());
   tap_timer_.Stop();
   OnTapTimerFired();
 }
 
 void TouchExplorationController::SetEventHandlerForTesting(
     ui::EventHandler* event_handler_for_testing) {
   event_handler_for_testing_ = event_handler_for_testing;
 }
 
 bool TouchExplorationController::IsInNoFingersDownStateForTesting() const {
   return state_ == NO_FINGERS_DOWN;
 }
 
-bool TouchExplorationController::IsInGestureInProgressStateForTesting() const {
-  return state_ == GESTURE_IN_PROGRESS;
-}
-
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
       VLOG(0) << "\nKeyboard event: " << key_event.name() << "\n"
               << " Key code: " << key_event.key_code()
               << ", Flags: " << key_event.flags()
               << ", Is char: " << key_event.is_char();
     }
+    if(event.IsGestureEvent()){
+      VLOG(0) << "\n Gesture event " << event.name();
+    }
     return ui::EVENT_REWRITE_CONTINUE;
   }
   const ui::TouchEvent& touch_event = static_cast<const ui::TouchEvent&>(event);
 
   // If the tap timer should have fired by now but hasn't, run it now and
   // stop the timer. This is important so that behavior is consistent with
   // the timestamps of the events, and not dependent on the granularity of
   // the timer.
   if (tap_timer_.IsRunning() &&
       touch_event.time_stamp() - initial_press_->time_stamp() >
@@ skipping 41 matching lines @@
       return InNoFingersDown(touch_event, rewritten_event);
     case SINGLE_TAP_PRESSED:
       return InSingleTapPressed(touch_event, rewritten_event);
     case SINGLE_TAP_RELEASED:
     case TOUCH_EXPLORE_RELEASED:
       return InSingleTapOrTouchExploreReleased(touch_event, rewritten_event);
     case DOUBLE_TAP_PRESSED:
       return InDoubleTapPressed(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
-    case GESTURE_IN_PROGRESS:
-      return InGestureInProgress(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
     case TWO_TO_ONE_FINGER:
       return InTwoToOneFinger(touch_event, rewritten_event);
     case PASSTHROUGH:
       return InPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_RELEASE:
       return InWaitForRelease(touch_event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
     const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     initial_press_.reset(new TouchEvent(event));
     last_unused_finger_event_.reset(new TouchEvent(event));
     tap_timer_.Start(FROM_HERE,
                      gesture_detector_config_.double_tap_timeout,
                      this,
                      &TouchExplorationController::OnTapTimerFired);
-    gesture_provider_.OnTouchEvent(event);
-    gesture_provider_.OnTouchEventAck(false);
-    ProcessGestureEvents();
     state_ = SINGLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
@@ skipping 10 matching lines @@
                                               event.touch_id(),
                                               event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     return EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     DCHECK_EQ(0U, current_touch_ids_.size());
     state_ = SINGLE_TAP_RELEASED;
     VLOG_STATE();
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
-    float distance = (event.location() - initial_press_->location()).Length();
-    // If the user does not move far enough from the original position, then the
-    // resulting movement should not be considered to be a deliberate gesture or
-    // touch exploration.
-    if (distance <= gesture_detector_config_.touch_slop)
-      return EVENT_REWRITE_DISCARD;
-
-    float delta_time =
-        (event.time_stamp() - initial_press_->time_stamp()).InSecondsF();
-    float velocity = distance / delta_time;
-    VLOG(0) << "\n Delta time: " << delta_time
-            << "\n Distance: " << distance
-            << "\n Velocity of click: " << velocity
-            << "\n Minimum swipe velocity: "
-            << gesture_detector_config_.minimum_swipe_velocity;
-
-    // If the user moves fast enough from the initial touch location, start
-    // gesture detection. Otherwise, jump to the touch exploration mode early.
-    if (velocity > gesture_detector_config_.minimum_swipe_velocity) {
-      state_ = GESTURE_IN_PROGRESS;
+    // If the user moves far enough from the initial touch location (outside
+    // the "slop" region, jump to the touch exploration mode early.
+    // TODO(evy, lisayin): Add gesture recognition here instead -
+    // we should probably jump to gesture mode here if the velocity is
+    // high enough, and touch exploration if the velocity is lower.
+    float delta = (event.location() - initial_press_->location()).Length();
+    if (delta > gesture_detector_config_.touch_slop) {
+      EnterTouchToMouseMode();
+      state_ = TOUCH_EXPLORATION;
       VLOG_STATE();
-      return InGestureInProgress(event, rewritten_event);
+      return InTouchExploration(event, rewritten_event);
     }
-    EnterTouchToMouseMode();
-    state_ = TOUCH_EXPLORATION;
-    VLOG_STATE();
-    return InTouchExploration(event, rewritten_event);
+    return EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus
 TouchExplorationController::InSingleTapOrTouchExploreReleased(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
-  // If there is more than one finger down, then discard to wait until only one
-  // finger is or no fingers are down.
-  if (current_touch_ids_.size() > 1) {
-    state_ = WAIT_FOR_RELEASE;
-    return ui::EVENT_REWRITE_DISCARD;
-  }
-  // If there is no touch exploration yet, discard.
-  if (!last_touch_exploration_ || type == ui::ET_TOUCH_RELEASED) {
-    if (current_touch_ids_.size() == 0) {
-      ResetToNoFingersDown();
-    }
-    return ui::EVENT_REWRITE_DISCARD;
-  }
-
   if (type == ui::ET_TOUCH_PRESSED) {
     // This is the second tap in a double-tap (or double tap-hold).
     // Rewrite at location of last touch exploration.
+    // If there is no touch exploration yet, discard instead.
+    if (!last_touch_exploration_) {
+      return ui::EVENT_REWRITE_DISCARD;
+    }
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                            last_touch_exploration_->location(),
                            event.touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     state_ = DOUBLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
+  } else if (type == ui::ET_TOUCH_RELEASED && !last_touch_exploration_) {
+    // If the previous press was discarded, we need to also handle its
+    // release.
+    if (current_touch_ids_.size() == 0) {
+      ResetToNoFingersDown();
+    }
+    return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InDoubleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() != 0)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite release at location of last touch exploration with the same
-    // id as the previous press.
+    // id as the prevoius press.
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
                            initial_press_->touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     ResetToNoFingersDown();
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
@@ skipping 32 matching lines @@
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
   *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
   last_touch_exploration_.reset(new TouchEvent(event));
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
-ui::EventRewriteStatus TouchExplorationController::InGestureInProgress(
-    const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
-  ui::EventType type = event.type();
-  // If additional fingers are added before a swipe gesture has been registered,
-  // then the state will no longer be GESTURE_IN_PROGRESS.
-  if (type == ui::ET_TOUCH_PRESSED ||
-      event.touch_id() != initial_press_->touch_id()) {
-    if (tap_timer_.IsRunning())
-      tap_timer_.Stop();
-    // Discard any pending gestures.
-    ignore_result(gesture_provider_.GetAndResetPendingGestures());
-    state_ = TWO_TO_ONE_FINGER;
-    last_two_to_one_.reset(new TouchEvent(event));
-    rewritten_event->reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                                              event.location(),
-                                              event.touch_id(),
-                                              event.time_stamp()));
-    (*rewritten_event)->set_flags(event.flags());
-    return EVENT_REWRITE_REWRITTEN;
-  }
-
-  // There should not be more than one finger down.
-  DCHECK(current_touch_ids_.size() <= 1);
-  if (type == ui::ET_TOUCH_MOVED) {
-    gesture_provider_.OnTouchEvent(event);
-    gesture_provider_.OnTouchEventAck(false);
-  }
-  if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
-    gesture_provider_.OnTouchEvent(event);
-    gesture_provider_.OnTouchEventAck(false);
-    if (current_touch_ids_.size() == 0)
-      ResetToNoFingersDown();
-  }
-
-  ProcessGestureEvents();
-  return ui::EVENT_REWRITE_DISCARD;
-}
 
 ui::EventRewriteStatus TouchExplorationController::InTwoToOneFinger(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   // The user should only ever be in TWO_TO_ONE_FINGER with two fingers down.
   // If the user added or removed a finger, the state is changed.
   ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     DCHECK(current_touch_ids_.size() == 1);
     // Stop passing through the second finger and go to the wait state.
@@ skipping 98 matching lines @@
     if (current_touch_ids_.size() != 1)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite at location of last touch exploration.
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
                            initial_press_->touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
-    EnterTouchToMouseMode();
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForRelease(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   if (!(type == ui::ET_TOUCH_PRESSED || type == ui::ET_TOUCH_MOVED ||
         type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED)) {
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (current_touch_ids_.size() == 0) {
     state_ = NO_FINGERS_DOWN;
-    VLOG_STATE();
     ResetToNoFingersDown();
   }
   return EVENT_REWRITE_DISCARD;
 }
 
 void TouchExplorationController::OnTapTimerFired() {
   switch (state_) {
     case SINGLE_TAP_RELEASED:
       ResetToNoFingersDown();
       break;
     case TOUCH_EXPLORE_RELEASED:
       ResetToNoFingersDown();
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       return;
     case SINGLE_TAP_PRESSED:
-    case GESTURE_IN_PROGRESS:
-      // Discard any pending gestures.
-      ignore_result(gesture_provider_.GetAndResetPendingGestures());
       EnterTouchToMouseMode();
       state_ = TOUCH_EXPLORATION;
       VLOG_STATE();
       break;
     default:
       return;
   }
-  scoped_ptr<ui::Event> mouse_move =
-      CreateMouseMoveEvent(initial_press_->location(), initial_press_->flags());
+
+  scoped_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
+      initial_press_->location(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
- }
+}
 
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   if (event_handler_for_testing_) {
     event_handler_for_testing_->OnEvent(event);
     return;
   }
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
-void TouchExplorationController::OnGestureEvent(ui::GestureEvent* gesture) {
-  CHECK(gesture->IsGestureEvent());
-  VLOG(0) << " \n Gesture Triggered: " << gesture->name();
-  if (gesture->type() == ui::ET_GESTURE_SWIPE) {
-    if (tap_timer_.IsRunning())
-      tap_timer_.Stop();
-    OnSwipeEvent(gesture);
-    return;
-  }
-}
-
-void TouchExplorationController::ProcessGestureEvents() {
-  scoped_ptr<ScopedVector<ui::GestureEvent> > gestures(
-      gesture_provider_.GetAndResetPendingGestures());
-  if (gestures) {
-    for (ScopedVector<GestureEvent>::iterator i = gestures->begin();
-         i != gestures->end();
-         ++i) {
-      OnGestureEvent(*i);
-    }
-  }
-}
-
-void TouchExplorationController::OnSwipeEvent(ui::GestureEvent* swipe_gesture) {
-  // A swipe gesture contains details for the direction in which the swipe
-  // occurred.
-  GestureEventDetails event_details = swipe_gesture->details();
-  if (event_details.swipe_left()) {
-    DispatchShiftSearchKeyEvent(ui::VKEY_LEFT);
-    return;
-  } else if (event_details.swipe_right()) {
-    DispatchShiftSearchKeyEvent(ui::VKEY_RIGHT);
-    return;
-  } else if (event_details.swipe_up()) {
-    DispatchShiftSearchKeyEvent(ui::VKEY_UP);
-    return;
-  } else if (event_details.swipe_down()) {
-    DispatchShiftSearchKeyEvent(ui::VKEY_DOWN);
-    return;
-  }
-}
-
-void TouchExplorationController::DispatchShiftSearchKeyEvent(
-    const ui::KeyboardCode direction) {
-  // In order to activate the shortcut shift+search+<arrow key>
-  // three KeyPressed events must be dispatched in succession along
-  // with three KeyReleased events.
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN, false));
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_PRESSED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN, false));
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN, false));
-
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN, false));
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_RELEASED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN, false));
-  DispatchEvent(new ui::KeyEvent(
-      ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE, false));
-}
-
 scoped_ptr<ui::Event> TouchExplorationController::CreateMouseMoveEvent(
     const gfx::PointF& location,
     int flags) {
   return scoped_ptr<ui::Event>(
       new ui::MouseEvent(
           ui::ET_MOUSE_MOVED,
           location,
           location,
           flags | ui::EF_IS_SYNTHESIZED | ui::EF_TOUCH_ACCESSIBILITY,
           0));
@@ skipping 58 matching lines @@
     case SINGLE_TAP_PRESSED:
       return "SINGLE_TAP_PRESSED";
     case SINGLE_TAP_RELEASED:
       return "SINGLE_TAP_RELEASED";
     case TOUCH_EXPLORE_RELEASED:
       return "TOUCH_EXPLORE_RELEASED";
     case DOUBLE_TAP_PRESSED:
       return "DOUBLE_TAP_PRESSED";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
-    case GESTURE_IN_PROGRESS:
-      return "GESTURE_IN_PROGRESS";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
     case TWO_TO_ONE_FINGER:
       return "TWO_TO_ONE_FINGER";
     case PASSTHROUGH:
       return "PASSTHROUGH";
     case WAIT_FOR_RELEASE:
       return "WAIT_FOR_RELEASE";
   }
   return "Not a state";
 }
 
 }  // namespace ui