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

ui/events/blink/blink_event_util.cc

 // Copyright 2015 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebPointerProperties;
 using blink::WebTouchEvent;
@@ skipping 137 matching lines @@
   static_assert(static_cast<int>(MotionEvent::MAX_TOUCH_POINT_COUNT) ==
                     static_cast<int>(blink::WebTouchEvent::touchesLengthCap),
                 "inconsistent maximum number of active touch points");
 
   blink::WebTouchEvent result;
 
   result.type = ToWebInputEventType(event.GetAction());
   result.dispatchType = result.type == WebInputEvent::TouchCancel
                             ? WebInputEvent::EventNonBlocking
                             : WebInputEvent::Blocking;
-  result.timeStampSeconds =
-      (event.GetEventTime() - base::TimeTicks()).InSecondsF();
+  result.timeStampSeconds = ui::EventTimeStampToSeconds(event.GetEventTime());
   result.movedBeyondSlopRegion = moved_beyond_slop_region;
   result.modifiers = EventFlagsToWebEventModifiers(event.GetFlags());
   DCHECK_NE(event.GetUniqueEventId(), 0U);
   result.uniqueTouchEventId = event.GetUniqueEventId();
   result.touchesLength =
       std::min(static_cast<unsigned>(event.GetPointerCount()),
                static_cast<unsigned>(WebTouchEvent::touchesLengthCap));
   DCHECK_GT(result.touchesLength, 0U);
 
   for (size_t i = 0; i < result.touchesLength; ++i)
@@ skipping 29 matching lines @@
     modifiers |= blink::WebInputEvent::RightButtonDown;
   if (flags & EF_IS_REPEAT)
     modifiers |= blink::WebInputEvent::IsAutoRepeat;
   if (flags & EF_TOUCH_ACCESSIBILITY)
     modifiers |= blink::WebInputEvent::IsTouchAccessibility;
 
   return modifiers;
 }
 
 WebGestureEvent CreateWebGestureEvent(const GestureEventDetails& details,
-                                      base::TimeDelta timestamp,
+                                      base::TimeTicks timestamp,
                                       const gfx::PointF& location,
                                       const gfx::PointF& raw_location,
                                       int flags) {
   WebGestureEvent gesture;
-  gesture.timeStampSeconds = timestamp.InSecondsF();
+  gesture.timeStampSeconds = ui::EventTimeStampToSeconds(timestamp);
   gesture.x = gfx::ToFlooredInt(location.x());
   gesture.y = gfx::ToFlooredInt(location.y());
   gesture.globalX = gfx::ToFlooredInt(raw_location.x());
   gesture.globalY = gfx::ToFlooredInt(raw_location.y());
   gesture.modifiers = EventFlagsToWebEventModifiers(flags);
 
   switch (details.device_type()) {
     case GestureDeviceType::DEVICE_TOUCHSCREEN:
       gesture.sourceDevice = blink::WebGestureDeviceTouchscreen;
       break;
@@ skipping 99 matching lines @@
     default:
       NOTREACHED() << "EventType provided wasn't a valid gesture event: "
                    << details.type();
   }
 
   return gesture;
 }
 
 WebGestureEvent CreateWebGestureEventFromGestureEventData(
     const GestureEventData& data) {
-  return CreateWebGestureEvent(data.details, data.time - base::TimeTicks(),
+  return CreateWebGestureEvent(data.details, data.time,
                                gfx::PointF(data.x, data.y),
                                gfx::PointF(data.raw_x, data.raw_y), data.flags);
 }
 
 std::unique_ptr<blink::WebInputEvent> ScaleWebInputEvent(
     const blink::WebInputEvent& event,
     float scale) {
   std::unique_ptr<blink::WebInputEvent> scaled_event;
   if (scale == 1.f)
     return scaled_event;
@@ skipping 108 matching lines @@
     case MotionEvent::TOOL_TYPE_MOUSE:
       return WebPointerProperties::PointerType::Mouse;
     case MotionEvent::TOOL_TYPE_ERASER:
       return WebPointerProperties::PointerType::Unknown;
   }
   NOTREACHED() << "Invalid MotionEvent::ToolType = " << tool_type;
   return WebPointerProperties::PointerType::Unknown;
 }
 
 }  // namespace ui