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

ui/events/x/events_x_utils.cc

 // Copyright (c) 2016 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.
 
 #include "ui/events/x/events_x_utils.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 294 matching lines @@
   return true;
 }
 
 int64_t g_last_seen_timestamp_ms = 0;
 // accumulated rollover time.
 int64_t g_rollover_ms = 0;
 std::unique_ptr<base::TickClock> g_tick_clock;
 
 // 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 this is the first event that we get, assume the time stamp roll-over
   // might have happened before the process was started.
   // Register a rollover if the distance between last timestamp and current one
   // is larger than half the width. This avoids false rollovers even in a case
   // where X server delivers reasonably close events out-of-order.
   bool had_recent_rollover =
       !g_last_seen_timestamp_ms ||
       g_last_seen_timestamp_ms - timestamp64 > (UINT32_MAX >> 1);
 
   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";
 
   base::TimeTicks now_ticks =
       g_tick_clock ? g_tick_clock->NowTicks() : base::TimeTicks::Now();
   int64_t now_ms = (now_ticks - base::TimeTicks()).InMilliseconds();
 
   g_rollover_ms = now_ms & ~static_cast<int64_t>(UINT32_MAX);
   uint32_t delta = static_cast<uint32_t>(now_ms - timestamp);
   // If using a mock clock, all bets are off -- in some tests, actual X11 events
   // come through with real timestamps.
   DCHECK(delta < 60 * 1000 || g_tick_clock)
       << "Unexpected X11 event time, now: " << now_ticks
       << " event at: " << timestamp;
-  return base::TimeDelta::FromMilliseconds(now_ms - delta);
+  return base::TimeTicks() + base::TimeDelta::FromMilliseconds(now_ms - delta);
 }
 
 }  // namespace
 
 namespace ui {
 
 EventType EventTypeFromXEvent(const XEvent& xev) {
   // Allow the DeviceDataManager to block the event. If blocked return
   // ET_UNKNOWN as the type so this event will not be further processed.
   // NOTE: During some events unittests there is no device data manager.
@@ skipping 156 matching lines @@
         case XI_KeyRelease: {
           XModifierStateWatcher::GetInstance()->UpdateStateFromXEvent(xev);
           return GetEventFlagsFromXGenericEvent(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 base::TimeTicks() +
+               base::TimeDelta::FromMicroseconds(end * 1000000);
       } else if (DeviceDataManagerX11::GetInstance()->GetEventData(
                      xev, DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP,
                      &touch_timestamp)) {
-        return base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000);
+        return base::TimeTicks() +
+               base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000);
       } 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) {
   switch (xev.type) {
     case EnterNotify:
     case LeaveNotify:
       return gfx::Point(xev.xcrossing.x, xev.xcrossing.y);
     case ButtonPress:
     case ButtonRelease:
       return gfx::Point(xev.xbutton.x, xev.xbutton.y);
@@ skipping 237 matching lines @@
 }
 
 void ResetTimestampRolloverCountersForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   g_last_seen_timestamp_ms = 0;
   g_rollover_ms = 0;
   g_tick_clock = std::move(tick_clock);
 }
 
 }  // namespace ui