Change ui::Event::time_stamp from TimeDelta to TimeTicks

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 59 matching lines @@
     DispatcherApi();
     Event* event_;
 
     DISALLOW_COPY_AND_ASSIGN(DispatcherApi);
   };
 
   const base::NativeEvent& native_event() const { return native_event_; }
   EventType type() const { return type_; }
   const std::string& name() const { return name_; }
   // time_stamp represents time since machine was booted.
-  const base::TimeDelta& time_stamp() const { return time_stamp_; }
+  const base::TimeTicks time_stamp() const { return time_stamp_; }
   int flags() const { return flags_; }
 
   // This is only intended to be used externally by classes that are modifying
   // events in an EventRewriter.
   void set_flags(int flags) { flags_ = flags; }
 
   EventTarget* target() const { return target_; }
   EventPhase phase() const { return phase_; }
   EventResult result() const { return result_; }
 
@@ skipping 184 matching lines @@
 
   // Marks the event as having been handled. A handled event does not reach the
   // next event phase. For example, if an event is handled during the pre-target
   // phase, then the event is dispatched to all pre-target handlers, but not to
   // the target or post-target handlers.
   // Note that SetHandled() can be called only for cancelable events.
   void SetHandled();
   bool handled() const { return result_ != ER_UNHANDLED; }
 
  protected:
-  Event(EventType type, base::TimeDelta time_stamp, int flags);
+  Event(EventType type, base::TimeTicks time_stamp, int flags);
   Event(const base::NativeEvent& native_event, EventType type, int flags);
   Event(const Event& copy);
   void SetType(EventType type);
   void set_cancelable(bool cancelable) { cancelable_ = cancelable; }
 
-  void set_time_stamp(const base::TimeDelta& time_stamp) {
+  void set_time_stamp(base::TimeTicks time_stamp) {
     time_stamp_ = time_stamp;
   }
 
   void set_name(const std::string& name) { name_ = name; }
 
  private:
   friend class EventTestApi;
 
   // For (de)serialization.
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
 
   EventType type_;
   std::string name_;
-  base::TimeDelta time_stamp_;
+  base::TimeTicks time_stamp_;
   LatencyInfo latency_;
   int flags_;
   base::NativeEvent native_event_;
   bool delete_native_event_;
   bool cancelable_;
   EventTarget* target_;
   EventPhase phase_;
   EventResult result_;
 
   // The device id the event came from, or ED_UNKNOWN_DEVICE if the information
   // is not available.
   int source_device_id_;
 };
 
 class EVENTS_EXPORT CancelModeEvent : public Event {
  public:
   CancelModeEvent();
   ~CancelModeEvent() override;
 
  private:
   // For (de)serialization.
-  CancelModeEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  CancelModeEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : Event(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::CancelModeEvent>;
 };
 
 class EVENTS_EXPORT LocatedEvent : public Event {
  public:
   ~LocatedEvent() override;
 
   float x() const { return location_.x(); }
@@ skipping 28 matching lines @@
     gfx::Point offset = gfx::ToFlooredPoint(location_);
     T::ConvertPointToTarget(source, target, &offset);
     gfx::Vector2d diff = gfx::ToFlooredPoint(location_) - offset;
     location_= location_ - diff;
   }
 
  protected:
   friend class LocatedEventTestApi;
 
   // For (de)serialization.
-  LocatedEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  LocatedEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : Event(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::LocatedEvent>;
 
   explicit LocatedEvent(const base::NativeEvent& native_event);
 
   // Create a new LocatedEvent 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>
   LocatedEvent(const LocatedEvent& model, T* source, T* target)
       : Event(model),
         location_(model.location_),
         root_location_(model.root_location_) {
     ConvertLocationToTarget(source, target);
   }
 
   // Used for synthetic events in testing.
   LocatedEvent(EventType type,
                const gfx::PointF& location,
                const gfx::PointF& root_location,
-               base::TimeDelta time_stamp,
+               base::TimeTicks time_stamp,
                int flags);
 
   gfx::PointF location_;
 
   // |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
@@ skipping 79 matching lines @@
         changed_button_flags_(model.changed_button_flags_),
         pointer_details_(model.pointer_details_) {
     SetType(type);
     set_flags(flags);
   }
 
   // Used for synthetic events in testing, gesture recognizer and Ozone
   MouseEvent(EventType type,
              const gfx::Point& location,
              const gfx::Point& root_location,
-             base::TimeDelta time_stamp,
+             base::TimeTicks time_stamp,
              int flags,
              int changed_button_flags);
 
   // Conveniences to quickly test what button is down
   bool IsOnlyLeftMouseButton() const {
     return button_flags() == EF_LEFT_MOUSE_BUTTON;
   }
 
   bool IsLeftMouseButton() const {
     return (flags() & EF_LEFT_MOUSE_BUTTON) != 0;
@@ skipping 49 matching lines @@
   void set_changed_button_flags(int flags) { changed_button_flags_ = flags; }
 
   // Event details common to MouseEvent and TouchEvent.
   const PointerDetails& pointer_details() const { return pointer_details_; }
   void set_pointer_details(const PointerDetails& details) {
     pointer_details_ = details;
   }
 
  protected:
   // For (de)serialization.
-  MouseEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  MouseEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : LocatedEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::MouseEvent>;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(EventTest, DoubleClickRequiresRelease);
   FRIEND_TEST_ALL_PREFIXES(EventTest, SingleClickRightLeft);
 
   // Returns the repeat count based on the previous mouse click, if it is
   // recent enough and within a small enough distance.
@@ skipping 33 matching lines @@
                   T* source,
                   T* target)
       : MouseEvent(model, source, target, model.type(), model.flags()),
         offset_(model.x_offset(), model.y_offset()) {
   }
 
   // Used for synthetic events in testing and by the gesture recognizer.
   MouseWheelEvent(const gfx::Vector2d& offset,
                   const gfx::Point& location,
                   const gfx::Point& root_location,
-                  base::TimeDelta time_stamp,
+                  base::TimeTicks time_stamp,
                   int flags,
                   int changed_button_flags);
 
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
   int x_offset() const { return offset_.x(); }
   int y_offset() const { return offset_.y(); }
   const gfx::Vector2d& offset() const { return offset_; }
 
  private:
   // For (de)serialization.
-  MouseWheelEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  MouseWheelEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : MouseEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::MouseWheelEvent>;
 
   gfx::Vector2d offset_;
 };
 
 class EVENTS_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
@@ skipping 10 matching lines @@
         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,
-             base::TimeDelta time_stamp);
+             base::TimeTicks time_stamp);
 
   TouchEvent(EventType type,
              const gfx::Point& location,
              int flags,
              int touch_id,
-             base::TimeDelta timestamp,
+             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.
@@ skipping 23 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:
   // For (de)serialization.
-  TouchEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  TouchEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : LocatedEvent(type, time_stamp, flags),
         should_remove_native_touch_id_mapping_(false) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::TouchEvent>;
 
   // 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.
@@ skipping 33 matching lines @@
   PointerEvent(const PointerEvent& pointer_event);
   explicit PointerEvent(const MouseEvent& mouse_event);
   explicit PointerEvent(const TouchEvent& touch_event);
 
   PointerEvent(EventType type,
                EventPointerType pointer_type,
                const gfx::Point& location,
                const gfx::Point& root_location,
                int flags,
                int pointer_id,
-               base::TimeDelta time_stamp);
+               base::TimeTicks time_stamp);
 
   int32_t pointer_id() const { return pointer_id_; }
   const PointerDetails& pointer_details() const { return details_; }
 
  protected:
   // For (de)serialization.
-  PointerEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  PointerEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : LocatedEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::PointerEvent>;
 
  private:
   int32_t pointer_id_;
   PointerDetails details_;
 };
 
 // An interface that individual platforms can use to store additional data on
@@ skipping 55 matching lines @@
   // Create a keystroke event from a legacy KeyboardCode.
   // This should not be used in new code.
   KeyEvent(EventType type, KeyboardCode key_code, int flags);
 
   // Create a fully defined keystroke event.
   KeyEvent(EventType type,
            KeyboardCode key_code,
            DomCode code,
            int flags,
            DomKey key,
-           base::TimeDelta time_stamp);
+           base::TimeTicks time_stamp);
 
   // Create a character event.
   KeyEvent(base::char16 character, KeyboardCode key_code, int flags);
 
   // Used for synthetic events with code of DOM KeyboardEvent (e.g. 'KeyA')
   // See also: ui/events/keycodes/dom/dom_values.txt
   KeyEvent(EventType type,
            KeyboardCode key_code,
            DomCode code,
            int flags);
@@ skipping 79 matching lines @@
   void NormalizeFlags();
 
  protected:
   friend class KeyEventTestApi;
 
   // This allows a subclass TranslatedKeyEvent to be a non character event.
   void set_is_char(bool is_char) { is_char_ = is_char; }
 
  private:
   // For (de)serialization.
-  KeyEvent(EventType type, base::TimeDelta time_stamp, int flags);
+  KeyEvent(EventType type, base::TimeTicks time_stamp, int flags);
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::KeyEvent>;
 
   // Determine key_ on a keystroke event from code_ and flags().
   void ApplyLayout() const;
 
   KeyboardCode key_code_;
 
   // DOM KeyboardEvent |code| (e.g. DomCode::US_A, DomCode::SPACE).
   // http://www.w3.org/TR/DOM-Level-3-Events-code/
@@ skipping 41 matching lines @@
         x_offset_(model.x_offset_),
         y_offset_(model.y_offset_),
         x_offset_ordinal_(model.x_offset_ordinal_),
         y_offset_ordinal_(model.y_offset_ordinal_),
         finger_count_(model.finger_count_){
   }
 
   // Used for tests.
   ScrollEvent(EventType type,
               const gfx::Point& location,
-              base::TimeDelta time_stamp,
+              base::TimeTicks time_stamp,
               int flags,
               float x_offset,
               float y_offset,
               float x_offset_ordinal,
               float y_offset_ordinal,
               int finger_count);
 
   // Scale the scroll event's offset value.
   // This is useful in the multi-monitor setup where it needs to be scaled
   // to provide a consistent user experience.
   void Scale(const float factor);
 
   float x_offset() const { return x_offset_; }
   float y_offset() const { return y_offset_; }
   float x_offset_ordinal() const { return x_offset_ordinal_; }
   float y_offset_ordinal() const { return y_offset_ordinal_; }
   int finger_count() const { return finger_count_; }
 
  private:
   // For (de)serialization.
-  ScrollEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  ScrollEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : MouseEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::ScrollEvent>;
 
   // Potential accelerated offsets.
   float x_offset_;
   float y_offset_;
   // Unaccelerated offsets.
   float x_offset_ordinal_;
   float y_offset_ordinal_;
   // Number of fingers on the pad.
   int finger_count_;
 };
 
 class EVENTS_EXPORT GestureEvent : public LocatedEvent {
  public:
   GestureEvent(float x,
                float y,
                int flags,
-               base::TimeDelta time_stamp,
+               base::TimeTicks time_stamp,
                const GestureEventDetails& details);
 
   // Create a new GestureEvent 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 <typename T>
   GestureEvent(const GestureEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
         details_(model.details_) {
   }
 
   ~GestureEvent() override;
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   // For (de)serialization.
-  GestureEvent(EventType type, base::TimeDelta time_stamp, int flags)
+  GestureEvent(EventType type, base::TimeTicks time_stamp, int flags)
       : LocatedEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::GestureEvent>;
 
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_