Set the unique_event_id when converting from TouchEvent to WebTouchEvent

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/trace_event/trace_event.h"
@@ skipping 199 matching lines @@
       return;
     Send(CreateGesture(ET_GESTURE_PINCH_END, e));
   }
 
   bool OnScale(const ScaleGestureDetector& detector,
                const MotionEvent& e) override {
     if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
     if (!pinch_event_sent_) {
       Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
-                         e.GetId(),
+                         e.GetPointerId(),
                          e.GetToolType(),
                          detector.GetEventTime(),
                          detector.GetFocusX(),
                          detector.GetFocusY(),
                          detector.GetFocusX() + e.GetRawOffsetX(),
                          detector.GetFocusY() + e.GetRawOffsetY(),
                          e.GetPointerCount(),
                          GetBoundingBox(e, ET_GESTURE_PINCH_BEGIN),
                          e.GetFlags()));
     }
@@ skipping 15 matching lines @@
       // 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));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE);
     pinch_details.set_scale(scale);
     Send(CreateGesture(pinch_details,
-                       e.GetId(),
+                       e.GetPointerId(),
                        e.GetToolType(),
                        detector.GetEventTime(),
                        detector.GetFocusX(),
                        detector.GetFocusY(),
                        detector.GetFocusX() + e.GetRawOffsetX(),
                        detector.GetFocusY() + e.GetRawOffsetY(),
                        e.GetPointerCount(),
                        GetBoundingBox(e, pinch_details.type()),
                        e.GetFlags()));
     return true;
@@ skipping 30 matching lines @@
       }
 
       // 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);
 
       // Use the co-ordinates from the touch down, as these co-ordinates are
       // used to determine which layer the scroll should affect.
       Send(CreateGesture(scroll_details,
-                         e2.GetId(),
+                         e2.GetPointerId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          e1.GetX(),
                          e1.GetY(),
                          e1.GetRawX(),
                          e1.GetRawY(),
                          e2.GetPointerCount(),
                          GetBoundingBox(e2, scroll_details.type()),
                          e2.GetFlags()));
       DCHECK(scroll_event_sent_);
     }
 
     snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal())
         distance_y = 0;
       else
         distance_x = 0;
     }
 
     if (distance_x || distance_y) {
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
       const gfx::RectF bounding_box = GetBoundingBox(e2, scroll_details.type());
       const gfx::PointF center = bounding_box.CenterPoint();
       const gfx::PointF raw_center =
           center + gfx::Vector2dF(e2.GetRawOffsetX(), e2.GetRawOffsetY());
       Send(CreateGesture(scroll_details,
-                         e2.GetId(),
+                         e2.GetPointerId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          center.x(),
                          center.y(),
                          raw_center.x(),
                          raw_center.y(),
                          e2.GetPointerCount(),
                          bounding_box,
                          e2.GetFlags()));
     }
@@ skipping 39 matching lines @@
     Send(CreateGesture(swipe_details, e2));
     return true;
   }
 
   bool OnTwoFingerTap(const MotionEvent& e1, const MotionEvent& e2) override {
     // The location of the two finger tap event should be the location of the
     // primary pointer.
     GestureEventDetails two_finger_tap_details(
         ET_GESTURE_TWO_FINGER_TAP, e1.GetTouchMajor(), e1.GetTouchMajor());
     Send(CreateGesture(two_finger_tap_details,
-                       e2.GetId(),
+                       e2.GetPointerId(),
                        e2.GetToolType(),
                        e2.GetEventTime(),
                        e1.GetX(),
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
                        GetBoundingBox(e2, two_finger_tap_details.type()),
                        e2.GetFlags()));
     return true;
@@ skipping 127 matching lines @@
                             raw_x,
                             raw_y,
                             touch_point_count,
                             bounding_box,
                             flags);
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  const MotionEvent& event) {
     return GestureEventData(details,
-                            event.GetId(),
+                            event.GetPointerId(),
                             event.GetToolType(),
                             event.GetEventTime(),
                             event.GetX(),
                             event.GetY(),
                             event.GetRawX(),
                             event.GetRawY(),
                             event.GetPointerCount(),
                             GetBoundingBox(event, details.type()),
                             event.GetFlags());
   }
@@ skipping 210 matching lines @@
       current_down_event_ = event.Clone();
       if (gesture_begin_end_types_enabled_)
         gesture_listener_->Send(
             gesture_listener_->CreateGesture(ET_GESTURE_BEGIN, event));
       break;
     case MotionEvent::ACTION_POINTER_DOWN:
       if (gesture_begin_end_types_enabled_) {
         const int action_index = event.GetActionIndex();
         gesture_listener_->Send(gesture_listener_->CreateGesture(
             ET_GESTURE_BEGIN,
-            event.GetId(),
+            event.GetPointerId(),
             event.GetToolType(),
             event.GetEventTime(),
             event.GetX(action_index),
             event.GetY(action_index),
             event.GetRawX(action_index),
             event.GetRawY(action_index),
             event.GetPointerCount(),
             gesture_listener_->GetBoundingBox(event, ET_GESTURE_BEGIN),
             event.GetFlags()));
       }
@@ skipping 37 matching lines @@
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled =
       double_tap_support_for_page_ && double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui