Added split tap to TouchExplorationController

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/timer/timer.h"
 #include "base/values.h"
 #include "ui/chromeos/ui_chromeos_export.h"
@@ skipping 42 matching lines @@
 //
 // If the user taps and releases their finger, after 300 ms from the initial
 // touch, a single mouse move is fired.
 //
 // 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.
 //
+// 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.
+//
 // If the user adds a second finger during the grace period, they enter
 // passthrough mode. In this mode, the first finger is ignored but all
 // additional touch events are mostly passed through unmodified. So a
 // two-finger scroll gets passed through as a one-finger scroll. However,
 // once in passthrough mode, if one finger is released, the remaining fingers
 // continue to pass through events, allowing the user to start a scroll
 // with two fingers but finish it with one. Sometimes this requires rewriting
 // the touch ids.
 //
 // Once either touch exploration or passthrough mode has been activated,
@@ skipping 25 matching lines @@
   ui::EventRewriteStatus InSingleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapReleased(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InDoubleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploration(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InPassthroughMinusOne(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
-
+  ui::EventRewriteStatus InTouchExploreSecondPress(
+      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   // This timer is started every time we get the first press event, and
   // it fires after the double-click timeout elapses (300 ms by default).
   // If the user taps and releases within 300 ms and doesn't press again,
   // we treat that as a single mouse move (touch exploration) event.
   void OnTapTimerFired();
 
   // Dispatch a new event outside of the event rewriting flow.
   void DispatchEvent(ui::Event* event);
 
   scoped_ptr<ui::Event> CreateMouseMoveEvent(const gfx::PointF& location,
@@ skipping 33 matching lines @@
 
     // The user placed two or more fingers down within the grace period.
     // We're now in passthrough mode until all fingers are lifted. Initially
     // the first finger is ignored and other fingers are passed through
     // as-is. If a finger other than the initial one is the first to be
     // released, we rewrite the first finger with the touch id of the finger
     // that was released, from now on. The motivation for this is that if
     // the user starts a scroll with 2 fingers, they can release either one
     // and continue the scrolling.
     PASSTHROUGH_MINUS_ONE,
+
+    // The user was in touch exploration, but has placed down another finger.
+    // If the user releases the second finger, a touch press and release
+    // will go through at the last touch explore location. If the user
+    // releases the touch explore finger, the other finger will continue with
+    // touch explore. Any fingers pressed past the first two are ignored.
+    TOUCH_EXPLORE_SECOND_PRESS,
   };
 
   void VlogState(const char* function_name);
 
   void VlogEvent(const ui::TouchEvent& event, const char* function_name);
 
   // Gets enum name from integer value.
   const char* EnumStateToString(State state);
 
   std::string EnumEventTypeToString(ui::EventType type);
@@ skipping 11 matching lines @@
   // initial finger are discarded. If kTouchIdNone, the initial finger
   // has been released and no more rewriting will be done.
   int initial_touch_id_passthrough_mapping_;
 
   // The current state.
   State state_;
 
   // A copy of the event from the initial touch press.
   scoped_ptr<ui::TouchEvent> initial_press_;
 
-  // The last location where we synthesized a mouse move event.
-  // When the user double-taps, we send the passed-through tap here.
-  gfx::PointF last_touch_exploration_location_;
+  // The last synthesized mouse move event. When the user double-taps,
+  // we send the passed-through tap to the location of this event.
+  scoped_ptr<ui::TouchEvent> last_touch_exploration_;
 
   // A timer to fire the mouse move event after the double-tap delay.
   base::OneShotTimer<TouchExplorationController> tap_timer_;
 
   // For testing only, an event handler to use for generated events
   // outside of the normal event rewriting flow.
   ui::EventHandler* event_handler_for_testing_;
 
   // A default gesture detector config, so we can share the same
   // timeout and pixel slop constants.
   ui::GestureDetector::Config gesture_detector_config_;
 
   // The previous state entered.
   State prev_state_;
 
   // A copy of the previous event passed.
   scoped_ptr<ui::TouchEvent> prev_event_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_