Fix the double-tap to click gesture in touch accessibility mode.

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 <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 19 matching lines @@
 const int kSoundDelayInMS = 150;
 
 }  // namespace
 
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window,
     TouchExplorationControllerDelegate* delegate)
     : root_window_(root_window),
       delegate_(delegate),
       state_(NO_FINGERS_DOWN),
+      anchor_point_state_(ANCHOR_POINT_NONE),
       gesture_provider_(new GestureProviderAura(this, this)),
       prev_state_(NO_FINGERS_DOWN),
       VLOG_on_(true),
       tick_clock_(NULL) {
   DCHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
+void TouchExplorationController::SetTouchAccessibilityAnchorPoint(
+    const gfx::Point& anchor_point) {
+  gfx::Point native_point = anchor_point;
+  root_window_->GetHost()->ConvertPointToNativeScreen(&native_point);
+
+  anchor_point_ = gfx::PointF(native_point.x(), native_point.y());
+  anchor_point_state_ = ANCHOR_POINT_EXPLICITLY_SET;
+}
+
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     std::unique_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();
@@ skipping 226 matching lines @@
       SET_STATE(SLIDE_GESTURE);
       return InSlideGesture(event, rewritten_event);
     }
 
     // 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) {
       SET_STATE(GESTURE_IN_PROGRESS);
       return InGestureInProgress(event, rewritten_event);
     }
+    anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
     EnterTouchToMouseMode();
     SET_STATE(TOUCH_EXPLORATION);
     return InTouchExploration(event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus
 TouchExplorationController::InSingleTapOrTouchExploreReleased(
     const ui::TouchEvent& event,
     std::unique_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 (!last_touch_exploration_) {
+    // If there is no anchor point for synthesized events because the
+    // user hasn't touch-explored or focused anything yet, we can't
+    // send a click, so discard.
+    if (anchor_point_state_ == ANCHOR_POINT_NONE) {
+      LOG(ERROR) << "*** NO ANCHOR POINT ***";
+
       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,
     // 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_) {
+  } else if (type == ui::ET_TOUCH_RELEASED &&
+             anchor_point_state_ == ANCHOR_POINT_NONE) {
     // 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();
@@ skipping 12 matching lines @@
     float delta = (event.location() - initial_press_->location()).Length();
     if (delta > gesture_detector_config_.touch_slop) {
       tap_timer_.Stop();
       OnTapTimerFired();
     }
     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;
 
-    std::unique_ptr<ui::TouchEvent> touch_press;
-    touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
-                                         initial_press_->touch_id(),
-                                         event.time_stamp()));
-    touch_press->set_location_f(last_touch_exploration_->location_f());
-    touch_press->set_root_location_f(last_touch_exploration_->location_f());
-    DispatchEvent(touch_press.get());
+    SendSimulatedClick();
 
-    std::unique_ptr<ui::TouchEvent> new_event(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
-                           initial_press_->touch_id(), event.time_stamp()));
-    new_event->set_location_f(last_touch_exploration_->location_f());
-    new_event->set_root_location_f(last_touch_exploration_->location_f());
-    new_event->set_flags(event.flags());
-    *rewritten_event = std::move(new_event);
     SET_STATE(NO_FINGERS_DOWN);
-    return ui::EVENT_REWRITE_REWRITTEN;
+    return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchReleasePending(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED || type == ui::ET_TOUCH_MOVED) {
     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;
 
-    std::unique_ptr<ui::TouchEvent> new_event(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
-                           initial_press_->touch_id(), event.time_stamp()));
-    new_event->set_location_f(last_touch_exploration_->location_f());
-    new_event->set_root_location_f(last_touch_exploration_->location_f());
-    new_event->set_flags(event.flags());
-    *rewritten_event = std::move(new_event);
+    SendSimulatedClick();
     SET_STATE(NO_FINGERS_DOWN);
-    return ui::EVENT_REWRITE_REWRITTEN;
+    return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchExploration(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
-    // Handle split-tap.
+    // Enter split-tap mode.
     initial_press_.reset(new TouchEvent(event));
     tap_timer_.Stop();
-    std::unique_ptr<ui::TouchEvent> new_event(
-        new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(), event.touch_id(),
-                           event.time_stamp()));
-    new_event->set_location_f(last_touch_exploration_->location_f());
-    new_event->set_root_location_f(last_touch_exploration_->location_f());
-    new_event->set_flags(event.flags());
-    *rewritten_event = std::move(new_event);
     SET_STATE(TOUCH_EXPLORE_SECOND_PRESS);
-    return ui::EVENT_REWRITE_REWRITTEN;
+    return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     initial_press_.reset(new TouchEvent(event));
     StartTapTimer();
     SET_STATE(TOUCH_EXPLORE_RELEASED);
   } else if (type != ui::ET_TOUCH_MOVED) {
     NOTREACHED();
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
   *rewritten_event = CreateMouseMoveEvent(event.location_f(), event.flags());
   last_touch_exploration_.reset(new TouchEvent(event));
+  if (anchor_point_state_ != ANCHOR_POINT_EXPLICITLY_SET)
+    anchor_point_ = last_touch_exploration_->location_f();
+
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InGestureInProgress(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   // The events were sent to the gesture provider in RewriteEvent already.
   // If no gesture is registered before the tap timer times out, the state
   // will change to "wait for no fingers down" or "touch exploration" depending
   // on the number of fingers down, and this function will stop being called.
@@ skipping 64 matching lines @@
   ui::EventType type = event.type();
   gfx::PointF location = event.location_f();
   if (type == ui::ET_TOUCH_PRESSED) {
     // A third finger being pressed means that a split tap can no longer go
     // through. The user enters the wait state, Since there has already been
     // a press dispatched when split tap began, the touch needs to be
     // cancelled.
     std::unique_ptr<ui::TouchEvent> new_event(
         new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(),
                            initial_press_->touch_id(), event.time_stamp()));
-    new_event->set_location_f(last_touch_exploration_->location_f());
-    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_location_f(anchor_point_);
+    new_event->set_root_location_f(anchor_point_);
     new_event->set_flags(event.flags());
     *rewritten_event = std::move(new_event);
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     // If the fingers have moved too far from their original locations,
     // the user can no longer split tap.
     ui::TouchEvent* original_touch;
     if (event.touch_id() == last_touch_exploration_->touch_id()) {
       original_touch = last_touch_exploration_.get();
     } else if (event.touch_id() == initial_press_->touch_id()) {
       original_touch = initial_press_.get();
     } else {
       NOTREACHED();
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return ui::EVENT_REWRITE_DISCARD;
     }
     // Check the distance between the current finger location and the original
     // location. The slop for this is a bit more generous since keeping two
     // fingers in place is a bit harder. If the user has left the slop, the
-    // split tap press (which was previous dispatched) is lifted with a touch
-    // cancelled, and the user enters the wait state.
+    // user enters the wait state.
     if ((event.location_f() - original_touch->location_f()).Length() >
         GetSplitTapTouchSlop()) {
-      std::unique_ptr<ui::TouchEvent> new_event(
-          new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(),
-                             initial_press_->touch_id(), event.time_stamp()));
-      new_event->set_location_f(last_touch_exploration_->location_f());
-      new_event->set_root_location_f(last_touch_exploration_->location_f());
-      new_event->set_flags(event.flags());
-      *rewritten_event = std::move(new_event);
       SET_STATE(WAIT_FOR_NO_FINGERS);
-      return ui::EVENT_REWRITE_REWRITTEN;
     }
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     // If the touch exploration finger is lifted, there is no option to return
     // to touch explore anymore. The remaining finger acts as a pending
     // tap or long tap for the last touch explore location.
     if (event.touch_id() == last_touch_exploration_->touch_id()) {
       SET_STATE(TOUCH_RELEASE_PENDING);
       return EVENT_REWRITE_DISCARD;
     }
 
     // Continue to release the touch only if the touch explore finger is the
     // only finger remaining.
     if (current_touch_ids_.size() != 1)
       return EVENT_REWRITE_DISCARD;
 
-    // Rewrite at location of last touch exploration.
-    std::unique_ptr<ui::TouchEvent> new_event(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
-                           initial_press_->touch_id(), event.time_stamp()));
-    new_event->set_location_f(last_touch_exploration_->location_f());
-    new_event->set_root_location_f(last_touch_exploration_->location_f());
-    new_event->set_flags(event.flags());
-    *rewritten_event = std::move(new_event);
+    SendSimulatedClick();
+
     SET_STATE(TOUCH_EXPLORATION);
     EnterTouchToMouseMode();
-    return ui::EVENT_REWRITE_REWRITTEN;
+    return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForNoFingers(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   if (current_touch_ids_.size() == 0)
     SET_STATE(NO_FINGERS_DOWN);
   return EVENT_REWRITE_DISCARD;
 }
 
 void TouchExplorationController::PlaySoundForTimer() {
   delegate_->PlayVolumeAdjustEarcon();
 }
 
+void TouchExplorationController::SendSimulatedClick() {
+  // If we got an anchor point from ChromeVox, send a double-tap gesture
+  // and let ChromeVox handle the click.
+  if (anchor_point_state_ == ANCHOR_POINT_EXPLICITLY_SET) {

[David Tseng, 2016/05/26 22:48:24]

I'm not entirely clear when the explicit vs touch explore state gets set. While
touch exploring, ChromeVox gets hover events and sets the focus rect. So,
depending on how quickly a user double taps thereafter, it could result in
either an explicit or touch explored click?

[dmazzoni, 2016/05/26 22:59:24]

Yes, that's right.

If you touch-explore and ChromeVox never identifies an object under the cursor,
double-tap will click on wherever your finger was. It's meant mainly as a
failsafe if ChromeVox isn't working, and I think it also does the
less-surprising thing if you just happen to be really fast.

If you touch-explore and ChromeVox does identify an object, ChromeVox's explicit
location takes precendence for the duration of that touch.

[David Tseng, 2016/06/01 00:36:15]

This is a little surprising to me because a ChromeVox user would click on
something that was never reflected in terms of output. Seems like something
useful for someone who can see the screen while using ChromeVox but possibly
confusing for a blind user.

+    delegate_->HandleAccessibilityGesture(ui::AX_GESTURE_CLICK);
+    return;
+  }
+
+  // If we don't have an anchor point, we can't send a simulated click.
+  if (anchor_point_state_ == ANCHOR_POINT_NONE)
+    return;
+
+  // Otherwise send a simulated press/release at the anchor point.
+  std::unique_ptr<ui::TouchEvent> touch_press;
+  touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
+                                       initial_press_->touch_id(), Now()));
+  touch_press->set_location_f(anchor_point_);
+  touch_press->set_root_location_f(anchor_point_);
+  DispatchEvent(touch_press.get());
+
+  std::unique_ptr<ui::TouchEvent> touch_release;
+  touch_release.reset(new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
+                                         initial_press_->touch_id(), Now()));
+  touch_release->set_location_f(anchor_point_);
+  touch_release->set_root_location_f(anchor_point_);
+  DispatchEvent(touch_release.get());
+}
+
 ui::EventRewriteStatus TouchExplorationController::InSlideGesture(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   // The timer should not fire when sliding.
   tap_timer_.Stop();
 
   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 ||
@@ skipping 82 matching lines @@
 }
 
 void TouchExplorationController::StartTapTimer() {
   tap_timer_.Start(FROM_HERE,
                    gesture_detector_config_.double_tap_timeout,
                    this,
                    &TouchExplorationController::OnTapTimerFired);
 }
 
 void TouchExplorationController::OnTapTimerFired() {
+  LOG(ERROR) << "** OnTapTimerFired **";

[David Tseng, 2016/05/26 22:48:24]

nit: remove

[dmazzoni, 2016/05/26 22:59:24]

Done.

   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_));
+      anchor_point_ = last_touch_exploration_->location_f();
+      anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
       return;
     case DOUBLE_TAP_PENDING: {
       SET_STATE(ONE_FINGER_PASSTHROUGH);
-      passthrough_offset_ = last_unused_finger_event_->location_f() -
-                            last_touch_exploration_->location_f();
+      passthrough_offset_ =
+          last_unused_finger_event_->location_f() - anchor_point_;
       std::unique_ptr<ui::TouchEvent> passthrough_press(
           new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
                              last_unused_finger_event_->touch_id(), Now()));
-      passthrough_press->set_location_f(last_touch_exploration_->location_f());
-      passthrough_press->set_root_location_f(
-          last_touch_exploration_->location_f());
+      passthrough_press->set_location_f(anchor_point_);
+      passthrough_press->set_root_location_f(anchor_point_);
       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) {
+        anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
         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:
       return;
   }
   EnterTouchToMouseMode();
   std::unique_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
       initial_press_->location_f(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
+  anchor_point_ = last_touch_exploration_->location_f();
+  anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
 }
 
 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.
 
   // 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;
 
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
@@ skipping 366 matching lines @@
       return "TWO_FINGER_TAP";
   }
   return "Not a state";
 }
 
 float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui