Add pointer id to the WebMouseEvent's constructors

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 29 matching lines @@
 class MouseEvent;
 class MouseWheelEvent;
 class PointerEvent;
 class ScrollEvent;
 class TouchEvent;
 enum class DomCode;
 class Event;
 class MouseWheelEvent;
 
 using ScopedEvent = std::unique_ptr<Event>;
+using PointerId = int32_t;
 
 class EVENTS_EXPORT Event {
  public:
   static std::unique_ptr<Event> Clone(const Event& event);
 
   virtual ~Event();
 
   class DispatcherApi {
    public:
     explicit DispatcherApi(Event* event) : event_(event) {}
@@ skipping 345 matching lines @@
   // 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,
-                          int pointer_id = kUnknownPointerId);
+                          PointerId pointer_id = kUnknownPointerId);
   PointerDetails(EventPointerType pointer_type,
-                 int pointer_id,
+                 PointerId pointer_id,
                  float radius_x,
                  float radius_y,
                  float force,
                  float tilt_x = 0.0f,
                  float tilt_y = 0.0f,
                  float tangential_pressure = 0.0f,
                  int twist = 0);
   PointerDetails(EventPointerType pointer_type,
                  const gfx::Vector2d& pointer_offset,
-                 int pointer_id = kUnknownPointerId);
+                 PointerId pointer_id = kUnknownPointerId);
   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 && id == other.id && offset == other.offset;
   }
 
   // A value for pointer id which means it needs to be initialized for all
   // pointer types.
-  static const int kUnknownPointerId;
+  static const PointerId kUnknownPointerId;
 
   // 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 @@
   // 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.
-  int id = 0;
+  PointerId 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:
-  static const int32_t kMousePointerId;
+  static const PointerId kMousePointerId;
 
   explicit MouseEvent(const base::NativeEvent& native_event);
 
   // |pointer_event.IsMousePointerEvent()| must be true.
   // Note: If |pointer_event| is a mouse wheel pointer event, use the
   // MouseWheelEvent version of this function to convert to a MouseWheelEvent
   // instead.
   explicit MouseEvent(const PointerEvent& pointer_event);
 
   // Create a new MouseEvent based on the provided model.
@@ skipping 558 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_