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 55 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;
 
   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
@@ skipping 59 matching lines @@
       : 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 76 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 96 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:
@@ skipping 16 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 70 matching lines @@
   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,
                const PointerDetails& pointer_details,
-               base::TimeDelta time_stamp);
+               base::TimeTicks time_stamp);
 
   int32_t pointer_id() const { return pointer_id_; }
   const PointerDetails& pointer_details() const { return details_; }
 
  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 136 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.
@@ skipping 14 matching lines @@
   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:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_