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

ui/chromeos/touch_exploration_controller.h

 // 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.
 
 #ifndef UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 #define UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 
 #include "base/macros.h"
 #include "base/time/tick_clock.h"
 #include "base/timer/timer.h"
@@ skipping 88 matching lines @@
 // (without performing a gesture), they enter touch exploration mode earlier
 // than 300 ms.
 //
 // If the user taps and releases their finger, after 300 ms from the initial
 // touch, a single mouse move is fired.
 //
 // While in touch exploration mode, the user can perform a single tap
 // if the user releases their finger and taps before 300 ms passes.
 // This will result in a click on the last successful touch exploration
 // location. This allows the user to perform a single tap
-// anywhere to activate it.
+// anywhere to activate it. (See more information on simulated clicks
+// below.)
 //
 // The user can perform swipe gestures in one of the four cardinal directions
 // which will be interpreted and used to control the UI. All gestures will only
 // be registered if the fingers move outside the slop, and all fingers will only
 // be registered if they are completed within the grace period. If a single
 // finger gesture fails to be completed within the grace period, the state
 // changes to touch exploration mode. If a multi finger gesture fails to be
 // completed within the grace period, the user must lift all fingers before
 // completing any more actions.
 //
-// If the user double-taps, the second tap is passed through, allowing the
-// user to click - however, the double-tap location is changed to the location
-// of the last successful touch exploration - that allows the user to explore
-// anywhere on the screen, hear its description, then double-tap anywhere
-// to activate it.
+// The user's initial tap sets the anchor point. Simulated events are
+// positioned relative to the anchor point, so that after exploring to find
+// an object the user can double-tap anywhere on the screen to activate it.
+// The anchor point is also set by ChromeVox every time it highlights an
+// object on the screen. During touch exploration this ensures that
+// any simulated events go to the center of the most recently highlighted
+// object, rather than to the exact tap location (which could have drifted
+// off of the object). This also ensures that when the current ChromeVox
+// object changes due to a gesture or input focus changing, simulated
+// events go to that object and not the last location touched by a finger.
 //
-// If the user double taps and holds, any event from that finger is passed
-// through. These events are passed through with an offset such that the first
-// touch is offset to be at the location of the last touch exploration
-// location, and every following event is offset by the same amount.
+// When the user double-taps, this is treated as a discrete gestures, and
+// and event is sent to ChromeVox to activate the current object, whatever
+// that is. However, when the user double-taps and holds, any event from that
+// finger is passed through, allowing the user to drag. These events are
+// passed through with a location that's relative to the anchor point.
 //
-// If any other fingers are added or removed, they are ignored. Once the
-// passthrough finger is released, passthrough stops and the user is reset
-// to no fingers down state.
+// If any other fingers are added or removed during a passthrough, they are
+// ignored. Once the passthrough finger is released, passthrough stops and
+// the state is reset to the no fingers down state.
 //
 // If the user enters touch exploration mode, they can click without lifting
 // their touch exploration finger by tapping anywhere else on the screen with
 // a second finger, while the touch exploration finger is still pressed.
 //
 // Once touch exploration mode has been activated, it remains in that mode until
 // all fingers have been released.
 //
 // If the user places a finger on the edge of the screen and moves their finger
 // past slop, a slide gesture is performed. The user can then slide one finger
@@ skipping 27 matching lines @@
 class UI_CHROMEOS_EXPORT TouchExplorationController
     : public ui::EventRewriter,
       public ui::GestureProviderAuraClient,
       public ui::GestureConsumer {
  public:
   explicit TouchExplorationController(
       aura::Window* root_window,
       ui::TouchExplorationControllerDelegate* delegate);
   ~TouchExplorationController() override;
 
+  // Make synthesized touch events are anchored at this point. This is
+  // called when the object with accessibility focus is updated via something
+  // other than touch exploration.
+  void SetTouchAccessibilityAnchorPoint(const gfx::Point& anchor_point);
+
  private:
   friend class TouchExplorationControllerTestApi;
 
   // Overridden from ui::EventRewriter
   ui::EventRewriteStatus RewriteEvent(
       const ui::Event& event,
       std::unique_ptr<ui::Event>* rewritten_event) override;
   ui::EventRewriteStatus NextDispatchEvent(
       const ui::Event& last_event,
       std::unique_ptr<ui::Event>* new_event) override;
@@ skipping 82 matching lines @@
   base::Closure BindKeyEventWithFlags(const ui::KeyboardCode key, int flags);
 
   std::unique_ptr<ui::MouseEvent> CreateMouseMoveEvent(
       const gfx::PointF& location,
       int flags);
 
   void EnterTouchToMouseMode();
 
   void PlaySoundForTimer();
 
+  void SendSimulatedClick();
+
   // Some constants used in touch_exploration_controller:
 
   // Within this many dips of the screen edge, the release event generated will
   // reset the state to NoFingersDown.
   const float kLeavingScreenEdge = 6;
 
   // Swipe/scroll gestures within these bounds (in DIPs) will change preset
   // settings.
   const float kMaxDistanceFromEdge = 75;
 
@@ skipping 84 matching lines @@
     // If the user is within the given bounds from an edge of the screen, not
     // including corners, then the resulting movements will be interpreted as
     // slide gestures.
     SLIDE_GESTURE,
 
     // If the user taps the screen with two fingers and releases both fingers
     // before the grace period has passed, spoken feedback will be silenced.
     TWO_FINGER_TAP,
   };
 
+  enum AnchorPointState {
+    ANCHOR_POINT_NONE,
+    ANCHOR_POINT_FROM_TOUCH_EXPLORATION,
+    ANCHOR_POINT_EXPLICITLY_SET
+  };
+
   enum ScreenLocation {
     // Hot "edges" of the screen are each represented by a respective bit.
     NO_EDGE = 0,
     RIGHT_EDGE = 1 << 0,
     TOP_EDGE = 1 << 1,
     LEFT_EDGE = 1 << 2,
     BOTTOM_EDGE = 1 << 3,
     BOTTOM_LEFT_CORNER = LEFT_EDGE | BOTTOM_EDGE,
     BOTTOM_RIGHT_CORNER = RIGHT_EDGE | BOTTOM_EDGE,
   };
@@ skipping 38 matching lines @@
 
   // In one finger passthrough, the touch is displaced relative to the
   // last touch exploration location.
   gfx::Vector2dF passthrough_offset_;
 
   // Stores the most recent event from a finger that is currently not
   // sending events through, but might in the future (e.g. before a finger
   // enters double-tap-hold passthrough, we need to update its location.)
   std::unique_ptr<ui::TouchEvent> last_unused_finger_event_;
 
-  // The last synthesized mouse move event. When the user double-taps,
-  // we send the passed-through tap to the location of this event.
+  // The anchor point used as the location of a synthesized tap when the
+  // user double-taps anywhere on the screen, and similarly the initial
+  // point used when the user double-taps, holds, and drags. This can be
+  // set either via touch exploration, or by a call to
+  // SetTouchAccessibilityAnchorPoint when focus moves due to something other
+  // than touch exploration.
+  gfx::PointF anchor_point_;
+
+  // The current state of the anchor point.
+  AnchorPointState anchor_point_state_;
+
+  // The last touch exploration event.
   std::unique_ptr<ui::TouchEvent> last_touch_exploration_;
 
   // A timer that fires after the double-tap delay.
   base::OneShotTimer tap_timer_;
 
   // A timer that fires to enter passthrough.
   base::OneShotTimer passthrough_timer_;
 
   // A timer to fire an indicating sound when sliding to change volume.
   base::RepeatingTimer sound_timer_;
@@ skipping 17 matching lines @@
   // When touch_exploration_controller gets time relative to real time during
   // testing, this clock is set to the simulated clock and used.
   base::TickClock* tick_clock_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_