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

ui/events/x/events_x_utils.cc

Index: ui/events/x/events_x_utils.cc
diff --git a/ui/events/x/events_x_utils.cc b/ui/events/x/events_x_utils.cc
index 27a49494041aec39f027f20cbb1de75758436c9a..be04deebaddd2b187669d106a74b2180f1240e78 100644
--- a/ui/events/x/events_x_utils.cc
+++ b/ui/events/x/events_x_utils.cc
@@ -21,6 +21,7 @@
 #include "build/build_config.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/devices/x11/device_data_manager_x11.h"
 #include "ui/events/devices/x11/device_list_cache_x11.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
@@ -307,27 +308,22 @@ bool GetGestureTimes(const XEvent& xev, double* start_time, double* end_time) {
   return true;
 }
 
-namespace {
 int64_t g_last_seen_timestamp_ms = 0;
 int64_t g_rollover_ms = 0;
 bool g_bogus_x11_timestamps = false;
 base::LazyInstance<std::unique_ptr<base::TickClock>>::Leaky g_tick_clock =
     LAZY_INSTANCE_INITIALIZER;
 
-}  // namespace
-
 // Takes Xlib Time and returns a time delta that is immune to timer rollover.
 // This function is not thread safe as we do not use a lock.
-base::TimeDelta TimeDeltaFromXEventTime(Time timestamp) {
+base::TimeTicks TimeTicksFromXEventTime(Time timestamp) {
   int64_t timestamp64 = timestamp;
 
   if (!timestamp)
-    return base::TimeDelta();
+    return base::TimeTicks();
 
-  if (g_bogus_x11_timestamps) {
-    return base::TimeDelta::FromInternalValue(
-        base::TimeTicks::Now().ToInternalValue());
-  }
+  if (g_bogus_x11_timestamps)
+    return base::TimeTicks::Now();
 
   // If this is the first event that we get, assume the time stamp roll-over
   // might have happened before the process was started.
@@ -340,7 +336,8 @@ base::TimeDelta TimeDeltaFromXEventTime(Time timestamp) {
 
   g_last_seen_timestamp_ms = timestamp64;
   if (!had_recent_rollover)
-    return base::TimeDelta::FromMilliseconds(g_rollover_ms + timestamp);
+    return base::TimeTicks() +
+           base::TimeDelta::FromMilliseconds(g_rollover_ms + timestamp);
 
   DCHECK(timestamp64 <= UINT32_MAX)
       << "X11 Time does not roll over 32 bit, the below logic is likely wrong";
@@ -365,7 +362,7 @@ base::TimeDelta TimeDeltaFromXEventTime(Time timestamp) {
                           !g_bogus_x11_timestamps);
   }
 
-  return base::TimeDelta::FromMilliseconds(now_ms - delta);
+  return base::TimeTicks() + base::TimeDelta::FromMilliseconds(now_ms - delta);
 }
 
 }  // namespace
@@ -541,41 +538,41 @@ int EventFlagsFromXEvent(const XEvent& xev) {
   return 0;
 }
 
-base::TimeDelta EventTimeFromXEvent(const XEvent& xev) {
+base::TimeTicks EventTimeFromXEvent(const XEvent& xev) {
   switch (xev.type) {
     case KeyPress:
     case KeyRelease:
-      return TimeDeltaFromXEventTime(xev.xkey.time);
+      return TimeTicksFromXEventTime(xev.xkey.time);
     case ButtonPress:
     case ButtonRelease:
-      return TimeDeltaFromXEventTime(xev.xbutton.time);
+      return TimeTicksFromXEventTime(xev.xbutton.time);
       break;
     case MotionNotify:
-      return TimeDeltaFromXEventTime(xev.xmotion.time);
+      return TimeTicksFromXEventTime(xev.xmotion.time);
       break;
     case EnterNotify:
     case LeaveNotify:
-      return TimeDeltaFromXEventTime(xev.xcrossing.time);
+      return TimeTicksFromXEventTime(xev.xcrossing.time);
       break;
     case GenericEvent: {
       double start, end;
       double touch_timestamp;
       if (GetGestureTimes(xev, &start, &end)) {
         // If the driver supports gesture times, use them.
-        return base::TimeDelta::FromMicroseconds(end * 1000000);
+        return ui::EventTimeStampFromSeconds(end);
       } else if (DeviceDataManagerX11::GetInstance()->GetEventData(
                      xev, DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP,
                      &touch_timestamp)) {
-        return base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000);
+        return ui::EventTimeStampFromSeconds(touch_timestamp);
       } else {
         XIDeviceEvent* xide = static_cast<XIDeviceEvent*>(xev.xcookie.data);
-        return TimeDeltaFromXEventTime(xide->time);
+        return TimeTicksFromXEventTime(xide->time);
       }
       break;
     }
   }
   NOTREACHED();
-  return base::TimeDelta();
+  return base::TimeTicks();
 }
 
 gfx::Point EventLocationFromXEvent(const XEvent& xev) {