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 295 matching lines @@
     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.
-    SET_STATE(DOUBLE_TAP_PENDING);
-    // The old tap timer (from the initial click) is stopped if it is still
-    // going, and the new one is set.
-    tap_timer_.Stop();
-    StartTapTimer();
-    // 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);
+    if (state_ == SINGLE_TAP_RELEASED) {

[dmazzoni, 2014/08/15 15:34:01]

This "if/else" block is now more than half of the function, so I think you
should split InSingleTapOrTouchExploreReleased into two functions,
InSingleTapReleased and InTouchExploreReleased. I'd far prefer to have a few
short lines of duplicate code between the two functions than to have this
function that does two increasingly different things.

[evy, 2014/08/15 16:14:57]

Done.

+      // This is the second tap in a double-tap (or double tap-hold).
+      // 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 passthrough timer is set.
+      tap_timer_.Stop();
+      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 (state_ == TOUCH_EXPLORE_RELEASED) {
+      // 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;
     }
-    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::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 283 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) {
         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";
       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: {
+      // 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";
+      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 365 matching lines @@
   left_swipe_gestures_[4] =
       BindKeyEventWithFlags(ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE);
   right_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BRIGHTNESS_UP, ui::EF_NONE);
   up_swipe_gestures_[4] = BindKeyEventWithFlags(VKEY_BROWSER_HOME, ui::EF_NONE);
   down_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BROWSER_REFRESH, ui::EF_NONE);
 }
 
 }  // namespace ui