Added multi-finger gestures to touch_exploration_controller

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 "base/time/default_tick_clock.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"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 #define VLOG_STATE() if (VLOG_IS_ON(0)) VlogState(__func__)
@@ skipping 13 matching lines @@
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window,
     TouchExplorationControllerDelegate* delegate)
     : root_window_(root_window),
       delegate_(delegate),
       state_(NO_FINGERS_DOWN),
       event_handler_for_testing_(NULL),
       gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN),
       VLOG_on_(true),
+      send_gesture_events_(false),
       tick_clock_(NULL) {
   CHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 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();
+    }
     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() >
           gesture_detector_config_.double_tap_timeout) {
     tap_timer_.Stop();
     OnTapTimerFired();
     // Note: this may change the state. We should now continue and process
     // this event under this new state.
   }
 
+  // If a gesture has ended, we need to keep proccessing touch events so that
+  // the gesture provider can keep track of how many fingers are down.
+  if (send_gesture_events_) {
+    gesture_provider_.OnTouchEvent(touch_event);
+    gesture_provider_.OnTouchEventAck(false);
+    delete gesture_provider_.GetAndResetPendingGestures();
+  }
+
   const ui::EventType type = touch_event.type();
   const gfx::PointF& location = touch_event.location_f();
   const int touch_id = touch_event.touch_id();
 
   // Always update touch ids and touch locations, so we can use those
   // no matter what state we're in.
   if (type == ui::ET_TOUCH_PRESSED) {
     current_touch_ids_.push_back(touch_id);
     touch_locations_.insert(std::pair<int, gfx::PointF>(touch_id, location));
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
-    // In order to avoid accidentally double tapping when moving off the edge of
-    // the screen, the state will be rewritten to NoFingersDown.
+    // In order to avoid accidentally double tapping when moving off the edge
+    // of the screen, the state will be rewritten to NoFingersDown.
     TouchEvent touch_event = static_cast<const TouchEvent&>(event);
     if (FindEdgesWithinBounds(touch_event.location(), kLeavingScreenEdge) !=
         NO_EDGE) {
       if (current_touch_ids_.size() == 0) {
         ResetToNoFingersDown();
       }
     }
 
     std::vector<int>::iterator it = std::find(
         current_touch_ids_.begin(), current_touch_ids_.end(), touch_id);
@@ skipping 10 matching lines @@
 
     // Can happen if touch exploration is enabled while fingers were down.
     if (it == current_touch_ids_.end())
       return ui::EVENT_REWRITE_CONTINUE;
 
     touch_locations_[*it] = location;
   }
   VLOG_STATE();
   VLOG_EVENT(touch_event);
   // The rest of the processing depends on what state we're in.
-  switch(state_) {
+  switch (state_) {
     case NO_FINGERS_DOWN:
       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_PENDING:
       return InDoubleTapPending(touch_event, rewritten_event);
     case TOUCH_RELEASE_PENDING:
       return InTouchReleasePending(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 SLIDE_GESTURE:
-      return InSlideGesture(touch_event, rewritten_event);
     case ONE_FINGER_PASSTHROUGH:
       return InOneFingerPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_ONE_FINGER:
       return InWaitForOneFinger(touch_event, rewritten_event);
+    case SLIDE_GESTURE:
+      return InSlideGesture(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;
 }
@@ skipping 14 matching lines @@
   }
   NOTREACHED() << "Unexpected event type received: " << event.name();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
   if (type == ui::ET_TOUCH_PRESSED) {
-    // TODO (evy, lisayin) : add support for multifinger swipes.
-    // For now, we wait for there to be only one finger down again.
-    state_ = WAIT_FOR_ONE_FINGER;
-    return EVENT_REWRITE_DISCARD;
+    // This is the start of a multifinger gesture.
+    state_ = GESTURE_IN_PROGRESS;
+    VLOG_STATE();
+    return InGestureInProgress(event, rewritten_event);
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() == 0 &&
         event.touch_id() == initial_press_->touch_id()) {
       state_ = SINGLE_TAP_RELEASED;
       VLOG_STATE();
     } else if (current_touch_ids_.size() == 0) {
       ResetToNoFingersDown();
     }
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
@@ skipping 39 matching lines @@
 
 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_ONE_FINGER;
+    VLOG_STATE();
     return ui::EVENT_REWRITE_DISCARD;
   }
   if (type == ui::ET_TOUCH_PRESSED) {
     // If there is no touch exploration yet, we can't send a click, so discard.
     if (!last_touch_exploration_) {
       tap_timer_.Stop();
       return ui::EVENT_REWRITE_DISCARD;
     }
     // This is the second tap in a double-tap (or double tap-hold).
     // We set the tap timer. If it fires before the user lifts their finger,
@@ skipping 113 matching lines @@
   // 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.
-    delete gesture_provider_.GetAndResetPendingGestures();
-    state_ = WAIT_FOR_ONE_FINGER;
-    return EVENT_REWRITE_DISCARD;
+  if (!(type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED ||

[aboxhall, 2014/07/30 00:25:15]

nit: this can be simplified to
if (type != ui::ET_TOUCH_RELEASED && type != ui::ET_TOUCH_CANCELLED && ...
Not much in it, but I find that way more readable as it's easy to miss the ! at
the start of the big disjunction there.

[evy, 2014/08/04 23:06:30]

Done.

+        type == ui::ET_TOUCH_MOVED || type == ui::ET_TOUCH_PRESSED)) {
+    NOTREACHED() << "Unexpected event type received: " << event.name();
+    return ui::EVENT_REWRITE_CONTINUE;
   }
-
-  // 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();
-    }
+  // Send events to the gesture provider. If no gesture is registered before
+  // the tap timer times out, the state will change to wait for one finger
+  // and this function will stop being called.
+  gesture_provider_.OnTouchEvent(event);
+  gesture_provider_.OnTouchEventAck(false);
+  if (current_touch_ids_.size() == 0) {
+    ResetToNoFingersDown();
   }
   ProcessGestureEvents();
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InOneFingerPassthrough(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
 
@@ skipping 66 matching lines @@
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForOneFinger(
     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: " << event.name();
     return ui::EVENT_REWRITE_CONTINUE;
   }
+
   if (current_touch_ids_.size() == 1) {
     EnterTouchToMouseMode();
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
     *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
     last_touch_exploration_.reset(new TouchEvent(event));
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   return EVENT_REWRITE_DISCARD;
 }
@@ skipping 12 matching lines @@
   ui::EventType type = event.type();
   // If additional fingers are added before a swipe gesture has been registered,
   // then wait until all fingers have been lifted.
   if (type == ui::ET_TOUCH_PRESSED ||
       event.touch_id() != initial_press_->touch_id()) {
     if (sound_timer_.IsRunning())
       sound_timer_.Stop();
     // Discard any pending gestures.
     delete gesture_provider_.GetAndResetPendingGestures();
     state_ = WAIT_FOR_ONE_FINGER;
+    VLOG_STATE();
     return EVENT_REWRITE_DISCARD;
   }
 
   // Allows user to return to the edge to adjust the sound if they have left the
   // boundaries.
   int edge = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
   if (!(edge & RIGHT_EDGE) && (type != ui::ET_TOUCH_RELEASED)) {
     if (sound_timer_.IsRunning()) {
       sound_timer_.Stop();
     }
@@ skipping 66 matching lines @@
                              last_touch_exploration_->location(),
                              last_unused_finger_event_->touch_id(),
                              Now()));
       DispatchEvent(passthrough_press.get());
       return;
     }
     case SINGLE_TAP_PRESSED:
     case GESTURE_IN_PROGRESS:
       // Discard any pending gestures.
       delete gesture_provider_.GetAndResetPendingGestures();
-      EnterTouchToMouseMode();
-      state_ = TOUCH_EXPLORATION;
+      // Wait for one finger before returning to touch exploration.
+      send_gesture_events_ = true;
+      state_ = WAIT_FOR_ONE_FINGER;
       VLOG_STATE();
       break;
     default:
       return;
   }
   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());
   ui::EventType type = gesture->type();
   if (VLOG_on_)
     VLOG(0) << " \n Gesture Triggered: " << gesture->name();
   if (type == ui::ET_GESTURE_SWIPE && state_ != SLIDE_GESTURE) {
-    if (VLOG_on_)
-      VLOG(0) << "Swipe!";
     delete gesture_provider_.GetAndResetPendingGestures();
     OnSwipeEvent(gesture);
+    send_gesture_events_ = true;
+    state_ = WAIT_FOR_ONE_FINGER;
+    VLOG_STATE();
+    tap_timer_.Stop();
     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();
@@ skipping 47 matching lines @@
   float ratio = (location.y() - kMaxDistanceFromEdge) / volume_adjust_height;
   float volume = 100 - 100 * ratio;
   if (VLOG_on_) {
     VLOG(0) << "\n Volume = " << volume
             << "\n Location = " << location.ToString()
             << "\n Bounds = " << root_window_->bounds().right();
   }
   delegate_->SetOutputLevel(int(volume));
 }
 
-
 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;
+  int num_fingers = event_details.touch_points();
+  if(VLOG_on_)
+    VLOG(0) << "\nSwipe with " << num_fingers << " fingers.";
+  switch (num_fingers) {
+    case 1:
+      if (event_details.swipe_left()) {
+        DispatchShiftSearchKeyEvent(ui::VKEY_LEFT);

[aboxhall, 2014/07/30 00:25:15]

Speculation: it might be nice to keep track of these in a data structure rather
than in code like this. Since you're forced to check the direction manually, you
could have a set of maps something like:
map<int, base::Closure> left_swipe_gestures = ...
left_swipe_gestures[1] = base::Bind(&DispatchShiftSearchKeyEvent,
ui::VKEY_LEFT);
...
and then
if (event_details.swipe_left()) {
  left_swipe_gestures[num_fingers].Run()
} else if (event_details.swipe_right() ...
Other reviewers might think this is a silly idea, though :) You'd also need to
handle the case where no action was mapped for that combination of swipe
direction and num_fingers.

[evy, 2014/08/04 23:06:30]

This is pretty cool! I'm not that familiar with maps, closures, and binds in
C++, but I'll definitely take a look.
I'm going to upload what I have right now so reviewers can compare the two
approaches - and also because I'd like review on the rest of what I've done so
far :)

+        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;
+      }
+    case 2:
+      if (event_details.swipe_left()) {
+        DispatchKeyWithNoFlags(VKEY_BROWSER_BACK);
+        return;
+      } else if (event_details.swipe_right()) {
+        DispatchKeyWithNoFlags(VKEY_BROWSER_FORWARD);
+        return;
+      } else if (event_details.swipe_up()) {
+        DispatchShiftSearchKeyEvent(ui::VKEY_A);
+        return;
+      } else if (event_details.swipe_down()) {
+        DispatchShiftSearchKeyEvent(ui::VKEY_R);
+        return;
+      }
+    case 3:
+      if (event_details.swipe_up()) {
+        DispatchKeyWithNoFlags(ui::VKEY_PRIOR);
+        return;
+      } else if (event_details.swipe_down()) {
+        DispatchKeyWithNoFlags(ui::VKEY_NEXT);
+        return;
+      }
+      // Left/right gestures mapping?
+      return;
+    case 4:
+      if (event_details.swipe_left()) {
+        // TODO: scroll through tabs
+        return;
+      } else if (event_details.swipe_right()) {
+        // TODO: scroll through tabs
+        return;
+      } else if (event_details.swipe_up()) {
+        DispatchKeyWithNoFlags(VKEY_BROWSER_HOME);
+        return;
+      } else if (event_details.swipe_down()) {
+        DispatchKeyWithNoFlags(VKEY_BROWSER_REFRESH);
+        return;
+      }
   }
+  // If the user is swiping with more than the supported number of fingers,
+  // none of these cases will be hit.
+  // TODO: add some checks so the gesture doesn't get proccessed if there are
+  // more fingers than supported.
+  return;
 }
 
 int TouchExplorationController::FindEdgesWithinBounds(gfx::Point point,
                                                       float bounds) {
   // Since GetBoundsInScreen is in DIPs but point is not, then point needs to be
   // converted.
   root_window_->GetHost()->ConvertPointFromNativeScreen(&point);
   gfx::Rect window = root_window_->GetBoundsInScreen();
 
   float left_edge_limit = window.x() + bounds;
@@ skipping 11 matching lines @@
   if (point.x() > right_edge_limit)
     result |= RIGHT_EDGE;
   if (point.y() < top_edge_limit)
     result |= TOP_EDGE;
   if (point.y() > bottom_edge_limit)
     result |= BOTTOM_EDGE;
   return result;
 }
 
 void TouchExplorationController::DispatchShiftSearchKeyEvent(
-    const ui::KeyboardCode direction) {
-  // In order to activate the shortcut shift+search+<arrow key>
+    const ui::KeyboardCode third_key) {
+  // In order to activate the shortcut shift+search+<key>
   // three KeyPressed events must be dispatched in succession along
   // with three KeyReleased events.
   ui::KeyEvent shift_down = ui::KeyEvent(
       ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN);
   ui::KeyEvent search_down = ui::KeyEvent(
       ui::ET_KEY_PRESSED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN);
-  ui::KeyEvent direction_down =
-      ui::KeyEvent(ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN);
+  ui::KeyEvent third_key_down =
+      ui::KeyEvent(ui::ET_KEY_PRESSED, third_key, ui::EF_SHIFT_DOWN);
 
-  ui::KeyEvent direction_up =
-      ui::KeyEvent(ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN);
+  ui::KeyEvent third_key_up =
+      ui::KeyEvent(ui::ET_KEY_RELEASED, third_key, ui::EF_SHIFT_DOWN);
   ui::KeyEvent search_up = ui::KeyEvent(
       ui::ET_KEY_RELEASED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN);
   ui::KeyEvent shift_up =
       ui::KeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE);
 
   DispatchEvent(&shift_down);
   DispatchEvent(&search_down);
-  DispatchEvent(&direction_down);
-  DispatchEvent(&direction_up);
+  DispatchEvent(&third_key_down);
+  DispatchEvent(&third_key_up);
   DispatchEvent(&search_up);
   DispatchEvent(&shift_up);
 }
 
+void TouchExplorationController::DispatchKeyWithNoFlags(
+    const ui::KeyboardCode key) {
+  ui::KeyEvent key_down = ui::KeyEvent(ui::ET_KEY_PRESSED, key, ui::EF_NONE);
+  ui::KeyEvent key_up = ui::KeyEvent(ui::ET_KEY_RELEASED, key, ui::EF_NONE);
+  DispatchEvent(&key_down);
+  DispatchEvent(&key_up);
+  if(VLOG_on_) {
+    VLOG(0) << "\nKey down: key code : " << key_down.key_code()
+            << ", flags: " << key_down.flags()
+            << "\nKey up: key code : " << key_up.key_code()
+            << ", flags: " << key_up.flags();
+  }
+}
+
 scoped_ptr<ui::Event> TouchExplorationController::CreateMouseMoveEvent(
     const gfx::PointF& location,
     int flags) {
   // The "synthesized" flag should be set on all events that don't have a
   // backing native event.
   flags |= ui::EF_IS_SYNTHESIZED;
 
   // This flag is used to identify mouse move events that were generated from
   // touch exploration in Chrome code.
   flags |= ui::EF_TOUCH_ACCESSIBILITY;
@@ skipping 23 matching lines @@
 }
 
 void TouchExplorationController::ResetToNoFingersDown() {
   ProcessGestureEvents();
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
   state_ = NO_FINGERS_DOWN;
   VLOG_STATE();
   if (tap_timer_.IsRunning())
     tap_timer_.Stop();
+  send_gesture_events_ = false;
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
   if (!VLOG_on_)
     return;
   if (prev_state_ == state_)
     return;
   prev_state_ = state_;
   const char* state_string = EnumStateToString(state_);
   VLOG(0) << "\n Function name: " << function_name
@@ skipping 43 matching lines @@
     case DOUBLE_TAP_PENDING:
       return "DOUBLE_TAP_PENDING";
     case TOUCH_RELEASE_PENDING:
       return "TOUCH_RELEASE_PENDING";
     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 SLIDE_GESTURE:
-      return "SLIDE_GESTURE";
     case ONE_FINGER_PASSTHROUGH:
       return "ONE_FINGER_PASSTHROUGH";
     case WAIT_FOR_ONE_FINGER:
       return "WAIT_FOR_ONE_FINGER";
+    case SLIDE_GESTURE:
+      return "SLIDE_GESTURE";
   }
   return "Not a state";
 }
 
 }  // namespace ui