Store the id of a contributing motion event in GestureEventData

ui/events/gesture_detection/gesture_provider.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/events/gesture_detection/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 13 matching lines @@
     case MotionEvent::ACTION_POINTER_UP:   return "ACTION_POINTER_UP";
     case MotionEvent::ACTION_DOWN:         return "ACTION_DOWN";
     case MotionEvent::ACTION_UP:           return "ACTION_UP";
     case MotionEvent::ACTION_CANCEL:       return "ACTION_CANCEL";
     case MotionEvent::ACTION_MOVE:         return "ACTION_MOVE";
   }
   return "";
 }
 
 GestureEventData CreateGesture(EventType type,
+                               int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
                                const GestureEventDetails& details) {
-  return GestureEventData(type, time, x, y, details);
+  return GestureEventData(type, motion_event_id, time, x, y, details);
 }
 
 GestureEventData CreateGesture(EventType type,
+                               int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y) {
-  return GestureEventData(type, time, x, y);
+  return GestureEventData(type, motion_event_id, time, x, y);
 }
 
 GestureEventData CreateGesture(EventType type,
                                const MotionEvent& event,
                                const GestureEventDetails& details) {
-  return CreateGesture(
-      type, event.GetEventTime(), event.GetX(), event.GetY(), details);
+  return CreateGesture(type,
+                       event.GetId(),
+                       event.GetEventTime(),
+                       event.GetX(),
+                       event.GetY(),
+                       details);
 }
 
 GestureEventData CreateGesture(EventType type,
                                const MotionEvent& event) {
-  return CreateGesture(type, event.GetEventTime(), event.GetX(), event.GetY());
+  return CreateGesture(
+      type, event.GetId(), event.GetEventTime(), event.GetX(), event.GetY());
 }
 
 GestureEventDetails CreateTapGestureDetails(EventType type,
                                             const MotionEvent& event) {
   // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
   // consistent with double tap behavior on a mobile viewport. See
   // crbug.com/234986 for context.
   GestureEventDetails tap_details(type, 1, 0);
   tap_details.set_bounding_box(
       gfx::RectF(event.GetTouchMajor(), event.GetTouchMajor()));
@@ skipping 28 matching lines @@
     bool handled = scale_gesture_detector_.OnTouchEvent(event);
     if (!in_scale_gesture &&
         (event.GetAction() == MotionEvent::ACTION_UP ||
          event.GetAction() == MotionEvent::ACTION_CANCEL)) {
       return false;
     }
     return handled;
   }
 
   // ScaleGestureDetector::ScaleGestureListener implementation.
-  virtual bool OnScaleBegin(const ScaleGestureDetector& detector) OVERRIDE {
+  virtual bool OnScaleBegin(const ScaleGestureDetector& detector,
+                            const MotionEvent& e) OVERRIDE {
     if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
       return false;
     pinch_event_sent_ = false;
     return true;
   }
 
-  virtual void OnScaleEnd(const ScaleGestureDetector& detector) OVERRIDE {
+  virtual void OnScaleEnd(const ScaleGestureDetector& detector,
+                          const MotionEvent& e) OVERRIDE {
     if (!pinch_event_sent_)
       return;
-    provider_->Send(
-        CreateGesture(ET_GESTURE_PINCH_END, detector.GetEventTime(), 0, 0));
+    provider_->Send(CreateGesture(
+        ET_GESTURE_PINCH_END, e.GetId(), detector.GetEventTime(), 0, 0));
     pinch_event_sent_ = false;
   }
 
-  virtual bool OnScale(const ScaleGestureDetector& detector) OVERRIDE {
+  virtual bool OnScale(const ScaleGestureDetector& detector,
+                       const MotionEvent& e) OVERRIDE {
     if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
       return false;
     if (!pinch_event_sent_) {
       pinch_event_sent_ = true;
       provider_->Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
+                                    e.GetId(),
                                     detector.GetEventTime(),
                                     detector.GetFocusX(),
                                     detector.GetFocusY()));
     }
 
     float scale = detector.GetScaleFactor();
     if (scale == 1)
       return true;
 
     if (detector.InDoubleTapMode()) {
       // Relative changes in the double-tap scale factor computed by |detector|
       // diminish as the touch moves away from the original double-tap focus.
       // For historical reasons, Chrome has instead adopted a scale factor
       // computation that is invariant to the focal distance, where
       // the scale delta remains constant if the touch velocity is constant.
       float dy =
           (detector.GetCurrentSpanY() - detector.GetPreviousSpanY()) * 0.5f;
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
                        std::abs(dy * px_to_dp_));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     provider_->Send(CreateGesture(ET_GESTURE_PINCH_UPDATE,
+                                  e.GetId(),
                                   detector.GetEventTime(),
                                   detector.GetFocusX(),
                                   detector.GetFocusY(),
                                   pinch_details));
     return true;
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     scale_gesture_detector_.SetQuickScaleEnabled(enabled);
@@ skipping 126 matching lines @@
     }
 
     last_raw_x_ = e2.GetRawX();
     last_raw_y_ = e2.GetRawY();
     if (!provider_->IsScrollInProgress()) {
       // Note that scroll start hints are in distance traveled, where
       // scroll deltas are in the opposite direction.
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_BEGIN, -raw_distance_x, -raw_distance_y);
       provider_->Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
+                                    e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
                                     scroll_details));
     }
 
     // distance_x and distance_y is the scrolling offset since last OnScroll.
     // Because we are passing integers to Blink, this could introduce
     // rounding errors. The rounding errors will accumulate overtime.
     // To solve this, we should be adding back the rounding errors each time
@@ skipping 19 matching lines @@
                        float velocity_x,
                        float velocity_y) OVERRIDE {
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         velocity_y = 0;
       } else {
         velocity_x = 0;
       }
     }
 
-    provider_->Fling(
-        e2.GetEventTime(), e1.GetX(), e1.GetY(), velocity_x, velocity_y);
+    provider_->Fling(e2, velocity_x, velocity_y);
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
     // TODO(jdduke): Expose minor axis length and rotation in |MotionEvent|.
     show_press_details.set_bounding_box(
         gfx::RectF(e.GetTouchMajor(), e.GetTouchMajor()));
     provider_->Send(
         CreateGesture(ET_GESTURE_SHOW_PRESS, e, show_press_details));
@@ skipping 197 matching lines @@
     SendTapCancelIfNecessary(event);
   }
 
   bool handled = gesture_listener_->OnTouchEvent(event, in_scale_gesture);
   handled |= scale_gesture_listener_->OnTouchEvent(event);
 
   if (event.GetAction() == MotionEvent::ACTION_UP ||
       event.GetAction() == MotionEvent::ACTION_CANCEL) {
     // Note: This call will have no effect if a fling was just generated, as
     // |Fling()| will have already signalled an end to touch-scrolling.
-    EndTouchScrollIfNecessary(event.GetEventTime(), true);
+    EndTouchScrollIfNecessary(event, true);
 
     // We shouldn't necessarily cancel a tap on ACTION_UP, as the double-tap
     // timeout may yet trigger a SINGLE_TAP.
     if (event.GetAction() == MotionEvent::ACTION_CANCEL)
       SendTapCancelIfNecessary(event);
 
     UpdateDoubleTapDetectionSupport();
 
     current_down_event_.reset();
   }
@@ skipping 57 matching lines @@
       config.snap_scroll_controller_config.device_scale_factor,
       this));
 
   UpdateDoubleTapDetectionSupport();
 }
 
 bool GestureProvider::CanHandle(const MotionEvent& event) const {
   return event.GetAction() == MotionEvent::ACTION_DOWN || current_down_event_;
 }
 
-void GestureProvider::Fling(base::TimeTicks time,
-                            float x,
-                            float y,
+void GestureProvider::Fling(const MotionEvent& event,
                             float velocity_x,
                             float velocity_y) {
   if (!velocity_x && !velocity_y) {
-    EndTouchScrollIfNecessary(time, true);
+    EndTouchScrollIfNecessary(event, true);
     return;
   }
 
   if (!touch_scroll_in_progress_) {
     // The native side needs a ET_GESTURE_SCROLL_BEGIN before
     // ET_SCROLL_FLING_START to send the fling to the correct target. Send if it
     // has not sent.  The distance traveled in one second is a reasonable scroll
     // start hint.
     GestureEventDetails scroll_details(
         ET_GESTURE_SCROLL_BEGIN, velocity_x, velocity_y);
-    Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN, time, x, y, scroll_details));
+    Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN, event, scroll_details));
   }
-  EndTouchScrollIfNecessary(time, false);
+  EndTouchScrollIfNecessary(event, false);
 
   GestureEventDetails fling_details(
       ET_SCROLL_FLING_START, velocity_x, velocity_y);
-  Send(CreateGesture(ET_SCROLL_FLING_START, time, x, y, fling_details));
+  Send(CreateGesture(
+      ET_SCROLL_FLING_START, event, fling_details));
 }
 
 void GestureProvider::Send(const GestureEventData& gesture) {
   DCHECK(!gesture.time.is_null());
   // The only valid events that should be sent without an active touch sequence
   // are SHOW_PRESS and TAP, potentially triggered by the double-tap
   // delay timing out.
   DCHECK(current_down_event_ || gesture.type == ET_GESTURE_TAP ||
          gesture.type == ET_GESTURE_SHOW_PRESS);
 
   switch (gesture.type) {
     case ET_GESTURE_TAP_DOWN:
       needs_tap_ending_event_ = true;
       break;
     case ET_GESTURE_TAP_UNCONFIRMED:
       needs_show_press_event_ = false;
       break;
     case ET_GESTURE_TAP:
       if (needs_show_press_event_)
-        Send(CreateGesture(
-            ET_GESTURE_SHOW_PRESS, gesture.time, gesture.x, gesture.y));
+        Send(CreateGesture(ET_GESTURE_SHOW_PRESS,
+                           gesture.motion_event_id,
+                           gesture.time,
+                           gesture.x,
+                           gesture.y));
       needs_tap_ending_event_ = false;
       break;
     case ET_GESTURE_DOUBLE_TAP:
       needs_tap_ending_event_ = false;
       break;
     case ET_GESTURE_TAP_CANCEL:
       if (!needs_tap_ending_event_)
         return;
       needs_tap_ending_event_ = false;
       break;
     case ET_GESTURE_SHOW_PRESS:
       needs_show_press_event_ = false;
       break;
     case ET_GESTURE_LONG_PRESS:
       DCHECK(!scale_gesture_listener_->IsScaleGestureDetectionInProgress());
       current_longpress_time_ = gesture.time;
       break;
     case ET_GESTURE_LONG_TAP:
       needs_tap_ending_event_ = false;
       current_longpress_time_ = base::TimeTicks();
       break;
     case ET_GESTURE_SCROLL_BEGIN:
       touch_scroll_in_progress_ = true;
-      SendTapCancelIfNecessary(*current_down_event_);
+      SendTapCancelIfNecessary(gesture);
       break;
     case ET_GESTURE_SCROLL_END:
       touch_scroll_in_progress_ = false;
       break;
     case ET_GESTURE_PINCH_BEGIN:
       if (!touch_scroll_in_progress_)
-        Send(CreateGesture(
-            ET_GESTURE_SCROLL_BEGIN, gesture.time, gesture.x, gesture.y));
+        Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
+                           gesture.motion_event_id,
+                           gesture.time,
+                           gesture.x,
+                           gesture.y));
       pinch_in_progress_ = true;
       break;
     case ET_GESTURE_PINCH_END:
       pinch_in_progress_ = false;
       break;
     default:
       break;
   };
 
   client_->OnGestureEvent(gesture);
 }
 
 void GestureProvider::SendTapCancelIfNecessary(const MotionEvent& event) {
   if (!needs_tap_ending_event_)
     return;
   current_longpress_time_ = base::TimeTicks();
   Send(CreateGesture(ET_GESTURE_TAP_CANCEL, event));
 }
 
+void GestureProvider::SendTapCancelIfNecessary(
+    const GestureEventData& gesture) {
+  if (!needs_tap_ending_event_)
+    return;
+  current_longpress_time_ = base::TimeTicks();
+  Send(CreateGesture(ET_GESTURE_TAP_CANCEL,
+                     gesture.motion_event_id,
+                     gesture.time,
+                     gesture.x,
+                     gesture.y));
+}
+
 bool GestureProvider::SendLongTapIfNecessary(const MotionEvent& event) {
   if (event.GetAction() == MotionEvent::ACTION_UP &&
       !current_longpress_time_.is_null() &&
       !scale_gesture_listener_->IsScaleGestureDetectionInProgress()) {
     SendTapCancelIfNecessary(event);
     GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP, 0, 0);
     long_tap_details.set_bounding_box(
         gfx::RectF(event.GetTouchMajor(), event.GetTouchMajor()));
     Send(CreateGesture(ET_GESTURE_LONG_TAP, event, long_tap_details));
     return true;
   }
   return false;
 }
 
-void GestureProvider::EndTouchScrollIfNecessary(base::TimeTicks time,
+void GestureProvider::EndTouchScrollIfNecessary(const MotionEvent& event,
                                                 bool send_scroll_end_event) {
   if (!touch_scroll_in_progress_)
     return;
   touch_scroll_in_progress_ = false;
   if (send_scroll_end_event)
-    Send(CreateGesture(ET_GESTURE_SCROLL_END, time, 0, 0));
+    Send(CreateGesture(ET_GESTURE_SCROLL_END, event));
 }
 
 void GestureProvider::UpdateDoubleTapDetectionSupport() {
   if (IsDoubleTapInProgress())
     return;
 
   const bool supports_double_tap = IsDoubleTapSupported();
   gesture_listener_->SetDoubleTapEnabled(supports_double_tap);
   scale_gesture_listener_->SetDoubleTapEnabled(supports_double_tap);
 }
 
 }  //  namespace ui