Add id properties to PointerEvent

ui/events/event.h

 // Copyright (c) 2012 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_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 390 matching lines @@
 
   // |location_| multiplied by an optional transformation matrix for
   // rotations, animations and skews.
   gfx::PointF root_location_;
 };
 
 // Structure for handling common fields between touch and mouse to support
 // PointerEvents API.
 struct EVENTS_EXPORT PointerDetails {
  public:
-  PointerDetails() {}
-  explicit PointerDetails(EventPointerType pointer_type)
-      : pointer_type(pointer_type),
-        force(std::numeric_limits<float>::quiet_NaN()) {}
+  PointerDetails();
+  explicit PointerDetails(EventPointerType pointer_type, uint32_t id = 0);
   PointerDetails(EventPointerType pointer_type,
                  float radius_x,
                  float radius_y,
                  float force,
                  float tilt_x,
                  float tilt_y,
                  float tangential_pressure = 0.0f,
-                 int twist = 0)
-      : pointer_type(pointer_type),
-        // If we aren't provided with a radius on one axis, use the
-        // information from the other axis.
-        radius_x(radius_x > 0 ? radius_x : radius_y),
-        radius_y(radius_y > 0 ? radius_y : radius_x),
-        force(force),
-        tilt_x(tilt_x),
-        tilt_y(tilt_y),
-        tangential_pressure(tangential_pressure),
-        twist(twist) {}
-  PointerDetails(EventPointerType pointer_type, const gfx::Vector2d& offset)
-      : pointer_type(pointer_type),
-        force(std::numeric_limits<float>::quiet_NaN()),
-        offset(offset) {}
+                 int twist = 0,
+                 uint32_t id = 0);
+  PointerDetails(EventPointerType pointer_type, const gfx::Vector2d& offset);
+  PointerDetails(const PointerDetails& other);
 
   bool operator==(const PointerDetails& other) const {
     return pointer_type == other.pointer_type && radius_x == other.radius_x &&
            radius_y == other.radius_y &&
            (force == other.force ||
             (std::isnan(force) && std::isnan(other.force))) &&
            tilt_x == other.tilt_x && tilt_y == other.tilt_y &&
            tangential_pressure == other.tangential_pressure &&
-           twist == other.twist && offset == other.offset;
+           twist == other.twist && id == other.id && offset == other.offset;
   }
 
   // The type of pointer device.
   EventPointerType pointer_type = EventPointerType::POINTER_TYPE_UNKNOWN;
 
   // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
   float radius_x = 0.0;
 
   // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
   float radius_y = 0.0;
@@ skipping 11 matching lines @@
   // The normalized tangential pressure (or barrel pressure), typically set by
   // an additional control of the stylus, which has a range of [-1,1], where 0
   // is the neutral position of the control. Always 0 if the device does not
   // support it.
   float tangential_pressure = 0.0;
 
   // The clockwise rotation of a pen stylus around its own major axis, in
   // degrees in the range [0,359]. Always 0 if the device does not support it.
   int twist = 0;
 
+  // An identifier that uniquely identifies a pointer during its lifetime.
+  uint32_t id = 0;
+
   // Only used by mouse wheel events. The amount to scroll. This is in multiples
   // of kWheelDelta.
   // Note: offset_.x() > 0/offset_.y() > 0 means scroll left/up.
   gfx::Vector2d offset;
 };
 
 class EVENTS_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
@@ skipping 169 matching lines @@
 
   // |pointer_event.IsTouchPointerEvent()| must be true.
   explicit TouchEvent(const PointerEvent& pointer_event);
 
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
-        touch_id_(model.touch_id_),
         unique_event_id_(model.unique_event_id_),
         rotation_angle_(model.rotation_angle_),
         may_cause_scrolling_(model.may_cause_scrolling_),
         should_remove_native_touch_id_mapping_(false),
         pointer_details_(model.pointer_details_) {}
 
   TouchEvent(EventType type,
              const gfx::Point& location,
-             int touch_id,
+             uint32_t touch_id,
              base::TimeTicks time_stamp);
 
   TouchEvent(EventType type,
              const gfx::Point& location,
              int flags,
-             int touch_id,
+             uint32_t touch_id,
              base::TimeTicks timestamp,
              float radius_x,
              float radius_y,
              float angle,
              float force);
 
   TouchEvent(const TouchEvent& copy);
 
   ~TouchEvent() override;
 
-  // The id of the pointer this event modifies.
-  int touch_id() const { return touch_id_; }
   // A unique identifier for this event.
   uint32_t unique_event_id() const { return unique_event_id_; }
 
   float rotation_angle() const { return rotation_angle_; }
 
   void set_may_cause_scrolling(bool causes) { may_cause_scrolling_ = causes; }
   bool may_cause_scrolling() const { return may_cause_scrolling_; }
 
   void set_should_remove_native_touch_id_mapping(
       bool should_remove_native_touch_id_mapping) {
@@ skipping 14 matching lines @@
   // Event details common to MouseEvent and TouchEvent.
   const PointerDetails& pointer_details() const { return pointer_details_; }
   void set_pointer_details(const PointerDetails& pointer_details) {
     pointer_details_ = pointer_details;
   }
 
  private:
   // Adjusts rotation_angle_ to within the acceptable range.
   void FixRotationAngle();
 
-  // The identity (typically finger) of the touch starting at 0 and incrementing
-  // for each separable additional touch that the hardware can detect.
-  int touch_id_;
-
   // A unique identifier for the touch event.
   uint32_t unique_event_id_;
 
   // Clockwise angle (in degrees) of the major axis from the X axis. Must be
   // less than 180 and non-negative.
   float rotation_angle_;
 
   // Whether the (unhandled) touch event will produce a scroll event (e.g., a
   // touchmove that exceeds the platform slop region, or a touchend that
   // causes a fling). Defaults to false.
   bool may_cause_scrolling_;
 
   // True if this event should remove the mapping between the native
   // event id and the touch_id_. This should only be the case for
   // release and cancel events where the associated touch press event
   // created a mapping between the native id and the touch_id_.
   bool should_remove_native_touch_id_mapping_;
 
   // Structure for holding pointer details for implementing PointerEvents API.
   PointerDetails pointer_details_;
 };
 
 class EVENTS_EXPORT PointerEvent : public LocatedEvent {
  public:
-  static const int32_t kMousePointerId;
+  static const uint32_t kMousePointerId;
 
   // Returns true if a PointerEvent can be constructed from |event|. Currently,
   // only mouse and touch events can be converted to pointer events.
   static bool CanConvertFrom(const Event& event);
 
   PointerEvent(const PointerEvent& pointer_event);
   explicit PointerEvent(const MouseEvent& mouse_event);
   explicit PointerEvent(const TouchEvent& touch_event);
 
   PointerEvent(EventType type,
                const gfx::Point& location,
                const gfx::Point& root_location,
                int flags,
-               int pointer_id,
+               uint32_t pointer_id,
                int changed_button_flags,
                const PointerDetails& pointer_details,
                base::TimeTicks time_stamp);
 
-  int32_t pointer_id() const { return pointer_id_; }
   int changed_button_flags() const { return changed_button_flags_; }
   void set_changed_button_flags(int flags) { changed_button_flags_ = flags; }
   const PointerDetails& pointer_details() const { return details_; }
 
  private:
-  int32_t pointer_id_;
   int changed_button_flags_;
   PointerDetails details_;
 };
 
 // A KeyEvent is really two distinct classes, melded together due to the
 // DOM legacy of Windows key events: a keystroke event (is_char_ == false),
 // or a character event (is_char_ == true).
 //
 // For a keystroke event,
 // -- |bool is_char_| is false.
@@ skipping 261 matching lines @@
   // dispatched. This field gets a non-zero value only for gestures that are
   // released through TouchDispositionGestureFilter::SendGesture. The gesture
   // events that aren't fired directly in response to processing a touch-event
   // (e.g. timer fired ones), this id is zero. See crbug.com/618738.
   uint32_t unique_touch_event_id_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_