Modified state flow for touch explore released in 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"
@@ skipping 143 matching lines @@
     ProcessGestureEvents();
   }
 
   // The rest of the processing depends on what state we're in.
   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:
+      return InSingleTapReleased(touch_event, rewritten_event);
     case TOUCH_EXPLORE_RELEASED:
-      return InSingleTapOrTouchExploreReleased(touch_event, rewritten_event);
+      return InTouchExploreReleased(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);
@@ skipping 119 matching lines @@
     }
     EnterTouchToMouseMode();
     SET_STATE(TOUCH_EXPLORATION);
     return InTouchExploration(event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus
-TouchExplorationController::InSingleTapOrTouchExploreReleased(
+TouchExplorationController::InSingleTapReleased(
     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 no
   // fingers are down.
   if (current_touch_ids_.size() > 1) {
     SET_STATE(WAIT_FOR_NO_FINGERS);
     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 there is no touch exploration yet, we can't send a click, so discard
+    // and wait for no fingers.
     if (!last_touch_exploration_) {
       tap_timer_.Stop();
+      SET_STATE(WAIT_FOR_NO_FINGERS);
       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,
-    // one-finger passthrough begins. Otherwise, there is a touch press and
-    // release at the location of the last touch exploration.
+    // We set the passthrough timer. If it fires before the user lifts their
+    // finger, one-finger passthrough begins. Otherwise, there is a touch
+    // press and release at the location of the last touch exploration.
     SET_STATE(DOUBLE_TAP_PENDING);
+    // Initial press now holds the intial double tap press - this event.
+    initial_press_.reset(new ui::TouchEvent(event));
     // The old tap timer (from the initial click) is stopped if it is still
-    // going, and the new one is set.
+    // going, and the passthrough timer is set.
     tap_timer_.Stop();
-    StartTapTimer();
+    passthrough_timer_.Start(
+        FROM_HERE,
+        gesture_detector_config_.longpress_timeout,
+        this,
+        &TouchExplorationController::OnPassthroughTimerFired);
     // This will update as the finger moves before a possible passthrough, and
     // will determine the offset.
     last_unused_finger_event_.reset(new ui::TouchEvent(event));
     return ui::EVENT_REWRITE_DISCARD;
-  } 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) {
-      SET_STATE(NO_FINGERS_DOWN);
-    }
-    return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
   }
+  NOTREACHED();
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+ui::EventRewriteStatus
+TouchExplorationController::InTouchExploreReleased(
+    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 no
+  // fingers are down.
+  if (current_touch_ids_.size() > 1) {
+    SET_STATE(WAIT_FOR_NO_FINGERS);
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+  if (type == ui::ET_TOUCH_PRESSED) {
+    // This is the initial "press" (location, time, and touch id) of a single
+    // tap click.
+    initial_press_.reset(new ui::TouchEvent(event));
+    rewritten_event->reset(
+        new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
+                           last_touch_exploration_->location(),
+                           initial_press_->touch_id(),
+                           event.time_stamp()));
+    (*rewritten_event)->set_flags(event.flags());
+    SET_STATE(TOUCH_RELEASE_PENDING);
+    return ui::EVENT_REWRITE_REWRITTEN;
+  } else if (type == ui::ET_TOUCH_MOVED) {
+    return ui::EVENT_REWRITE_DISCARD;
+  }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InDoubleTapPending(
     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_MOVED) {
     // If the user moves far enough from the initial touch location (outside
     // the "slop" region, jump to passthrough mode early.
     float delta = (event.location() - initial_press_->location()).Length();
     if (delta > gesture_detector_config_.touch_slop) {
-      tap_timer_.Stop();
-      OnTapTimerFired();
+      passthrough_timer_.Stop();
+      if (VLOG_on_)
+        VLOG(0) << "Finger left slop and is entering passthrough";
+      OnPassthroughTimerFired();
     }
     return 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;
 
+    // Now it is recognized that the user was doing a double tap to click.
+    // The passthrough timer is stopped and a touch press and release are
+    // dispatched.
+    passthrough_timer_.Stop();
+
     scoped_ptr<ui::TouchEvent> touch_press;
     touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                                          last_touch_exploration_->location(),
                                          initial_press_->touch_id(),
                                          event.time_stamp()));
     DispatchEvent(touch_press.get());
 
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
@@ skipping 320 matching lines @@
 
 void TouchExplorationController::OnTapTimerFired() {
   switch (state_) {
     case SINGLE_TAP_RELEASED:
       SET_STATE(NO_FINGERS_DOWN);
       break;
     case TOUCH_EXPLORE_RELEASED:
       SET_STATE(NO_FINGERS_DOWN);
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       return;
-    case DOUBLE_TAP_PENDING: {
-      SET_STATE(ONE_FINGER_PASSTHROUGH);
-      passthrough_offset_ = last_unused_finger_event_->location() -
-                            last_touch_exploration_->location();
-      scoped_ptr<ui::TouchEvent> passthrough_press(
-          new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                             last_touch_exploration_->location(),
-                             last_unused_finger_event_->touch_id(),
-                             Now()));
-      DispatchEvent(passthrough_press.get());
-      return;
-    }
     case SINGLE_TAP_PRESSED:
       if (passthrough_timer_.IsRunning())
         return;
     case GESTURE_IN_PROGRESS:
       // If only one finger is down, go into touch exploration.
       if (current_touch_ids_.size() == 1) {
         EnterTouchToMouseMode();
         SET_STATE(TOUCH_EXPLORATION);
         break;
       }
       // Otherwise wait for all fingers to be lifted.
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return;
     case TWO_FINGER_TAP:
       SET_STATE(WAIT_FOR_NO_FINGERS);
       break;
     default:
+      NOTREACHED() << "tap timer fired in unrecognized state";

[aboxhall, 2014/08/15 18:30:32]

Suggestion: log the state?

[evy, 2014/08/15 18:39:12]

Done.

       return;
   }
   EnterTouchToMouseMode();
   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::OnPassthroughTimerFired() {
-  // The passthrough timer will only fire if if the user has held a finger in
-  // one of the passthrough corners for the duration of the passthrough timeout.
+  switch (state_) {
+    case SINGLE_TAP_PRESSED:
+    case TOUCH_EXPLORATION:
+    case GESTURE_IN_PROGRESS: {
+      // The timer will only fire in this state if if the user has held a finger
+      // in one of the passthrough corners for the duration of the passthrough
+      // timeout.
 
-  // Check that initial press isn't null. Also a check that if the initial
-  // corner press was released, then it should not be in corner passthrough.
-  if (!initial_press_ ||
-      touch_locations_.find(initial_press_->touch_id()) !=
-          touch_locations_.end()) {
-    LOG(ERROR) << "No initial press or the initial press has been released.";
+      // Check that initial press isn't null. Also a check that if the initial
+      // corner press was released, then it should not be in corner passthrough.
+      if (!initial_press_ ||
+          touch_locations_.find(initial_press_->touch_id()) !=
+              touch_locations_.end()) {
+        LOG(ERROR)
+            << "No initial press or the initial press has been released.";
+      }
+
+      gfx::Point location =
+          ToRoundedPoint(touch_locations_[initial_press_->touch_id()]);
+      int corner = FindEdgesWithinBounds(location, kSlopDistanceFromEdge);
+      if (corner != BOTTOM_LEFT_CORNER && corner != BOTTOM_RIGHT_CORNER)
+        return;
+
+      SET_STATE(CORNER_PASSTHROUGH);
+      break;
+    }
+    case DOUBLE_TAP_PENDING: {

[dmazzoni, 2014/08/15 16:54:45]

Nit: I don't think you need { } in this case. You only need it if you also
declare local variables, so that case above needs it.

[evy, 2014/08/15 17:03:03]

I declare passthrough_press 

[dmazzoni, 2014/08/15 17:29:05]

Oh, of course. Nevermind, this is fine.

+      // Enter one finger passthrough mode.
+      SET_STATE(ONE_FINGER_PASSTHROUGH);
+      passthrough_offset_ = last_unused_finger_event_->location() -
+                            last_touch_exploration_->location();
+      scoped_ptr<ui::TouchEvent> passthrough_press(
+          new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
+                             last_touch_exploration_->location(),
+                             last_unused_finger_event_->touch_id(),
+                             Now()));
+      DispatchEvent(passthrough_press.get());
+      break;
+    }
+    default:
+      NOTREACHED() << "passthrough timer fired in unrecognized state";

[aboxhall, 2014/08/15 18:30:32]

Similarly, maybe log state?

[evy, 2014/08/15 18:39:12]

Done.

+      return;
   }
-
-  gfx::Point location =
-      ToRoundedPoint(touch_locations_[initial_press_->touch_id()]);
-  int corner = FindEdgesWithinBounds(location, kSlopDistanceFromEdge);
-  if (corner != BOTTOM_LEFT_CORNER && corner != BOTTOM_RIGHT_CORNER)
-    return;
-
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
   delegate_->PlayPassthroughEarcon();
-  SET_STATE(CORNER_PASSTHROUGH);
-  return;
 }
 
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
 // This is an override for a function that is only called for timer-based events
 // like long press. Events that are created synchronously as a result of
 // certain touch events are added to the vector accessible via
@@ skipping 369 matching lines @@
   up_swipe_gestures_[4] = BindKeyEventWithFlags(VKEY_BROWSER_HOME, ui::EF_NONE);
   down_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BROWSER_REFRESH, ui::EF_NONE);
 }
 
 const float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui