Use WTF::TimeTicks to represent timestamp in Platform/Core event types

third_party/WebKit/Source/web/WebInputEventConversion.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 47 matching lines @@
       scale = rootView->inputEventsScaleFactor();
   }
   return delta / scale;
 }
 
 FloatSize scaleSizeToWindow(const Widget* widget, FloatSize size) {
   return FloatSize(scaleDeltaToWindow(widget, size.width()),
                    scaleDeltaToWindow(widget, size.height()));
 }
 
+TimeTicks toTimeTicks(double eventTimeStampSeconds) {
+  return TimeTicks() + TimeDelta::FromSecondsD(eventTimeStampSeconds);

[esprehn, 2016/12/06 22:14:19]

Can you add a method to TimeTicks for FromSeconds() ?

+}
+
+double toSeconds(TimeTicks ticks) {
+  return (ticks - TimeTicks()).InSecondsF();

[esprehn, 2016/12/06 22:14:19]

Why does TimeTicks not have a ToSecondsF() method that subtracts the "zero" from
it?

I'm concerned the base API seems to require a bunch of boilerplate all over.

+}
+
 // This method converts from the renderer's coordinate space into Blink's root
 // frame coordinate space.  It's somewhat unique in that it takes into account
 // DevTools emulation, which applies a scale and offset in the root layer (see
 // updateRootLayerTransform in WebViewImpl) as well as the overscroll effect on
 // OSX.  This is in addition to the visual viewport "pinch-zoom" transformation
 // and is one of the few cases where the visual viewport is not equal to the
 // renderer's coordinate-space.
 FloatPoint convertHitPointToRootFrame(const Widget* widget,
                                       FloatPoint pointInRendererViewport) {
   float scale = 1;
@@ skipping 118 matching lines @@
                                                      const WebMouseEvent& e) {
   // FIXME: Widget is always toplevel, unless it's a popup. We may be able
   // to get rid of this once we abstract popups into a WebKit API.
   m_position = widget->convertFromRootFrame(
       flooredIntPoint(convertHitPointToRootFrame(widget, IntPoint(e.x, e.y))));
   m_globalPosition = IntPoint(e.globalX, e.globalY);
   m_movementDelta = IntPoint(scaleDeltaToWindow(widget, e.movementX),
                              scaleDeltaToWindow(widget, e.movementY));
   m_modifiers = e.modifiers;
 
-  m_timestamp = e.timeStampSeconds;
+  m_timestamp = toTimeTicks(e.timeStampSeconds);
   m_clickCount = e.clickCount;
 
   m_pointerProperties = static_cast<WebPointerProperties>(e);
 
   switch (e.type) {
     case WebInputEvent::MouseMove:
     case WebInputEvent::MouseEnter:  // synthesize a move event
     case WebInputEvent::MouseLeave:  // synthesize a move event
       m_type = PlatformEvent::MouseMoved;
       break;
@@ skipping 27 matching lines @@
   m_globalPosition = IntPoint(e.globalX, e.globalY);
   m_deltaX = scaleDeltaToWindow(widget, e.deltaX);
   m_deltaY = scaleDeltaToWindow(widget, e.deltaY);
   m_wheelTicksX = e.wheelTicksX;
   m_wheelTicksY = e.wheelTicksY;
   m_granularity =
       e.scrollByPage ? ScrollByPageWheelEvent : ScrollByPixelWheelEvent;
 
   m_type = PlatformEvent::Wheel;
 
-  m_timestamp = e.timeStampSeconds;
+  m_timestamp = toTimeTicks(e.timeStampSeconds);
   m_modifiers = e.modifiers;
   m_dispatchType = toPlatformDispatchType(e.dispatchType);
 
   m_hasPreciseScrollingDeltas = e.hasPreciseScrollingDeltas;
   m_resendingPluginId = e.resendingPluginId;
   m_railsMode = static_cast<PlatformEvent::RailsMode>(e.railsMode);
 #if OS(MACOSX)
   m_phase = static_cast<PlatformWheelEventPhase>(e.phase);
   m_momentumPhase = static_cast<PlatformWheelEventPhase>(e.momentumPhase);
 #endif
@@ skipping 103 matching lines @@
     case WebInputEvent::GesturePinchUpdate:
       m_type = PlatformEvent::GesturePinchUpdate;
       m_data.m_pinchUpdate.m_scale = e.data.pinchUpdate.scale;
       break;
     default:
       NOTREACHED();
   }
   m_position = widget->convertFromRootFrame(flooredIntPoint(
       convertHitPointToRootFrame(widget, FloatPoint(e.x, e.y))));
   m_globalPosition = IntPoint(e.globalX, e.globalY);
-  m_timestamp = e.timeStampSeconds;
+  m_timestamp = toTimeTicks(e.timeStampSeconds);
   m_modifiers = e.modifiers;
   switch (e.sourceDevice) {
     case WebGestureDeviceTouchpad:
       m_source = PlatformGestureSourceTouchpad;
       break;
     case WebGestureDeviceTouchscreen:
       m_source = PlatformGestureSourceTouchscreen;
       break;
     case WebGestureDeviceUninitialized:
       NOTREACHED();
@@ skipping 67 matching lines @@
   m_screenPos = FloatPoint(point.screenPosition.x, point.screenPosition.y);
   m_radius = scaleSizeToWindow(widget, FloatSize(point.radiusX, point.radiusY));
   m_rotationAngle = point.rotationAngle;
 }
 
 PlatformTouchEventBuilder::PlatformTouchEventBuilder(
     Widget* widget,
     const WebTouchEvent& event) {
   m_type = toPlatformTouchEventType(event.type);
   m_modifiers = event.modifiers;
-  m_timestamp = event.timeStampSeconds;
+  m_timestamp = toTimeTicks(event.timeStampSeconds);
   m_causesScrollingIfUncanceled = event.movedBeyondSlopRegion;
   m_touchStartOrFirstTouchMove = event.touchStartOrFirstTouchMove;
 
   for (unsigned i = 0; i < event.touchesLength; ++i)
     m_touchPoints.append(PlatformTouchPointBuilder(widget, event.touches[i]));
 
   m_dispatchType = toPlatformDispatchType(event.dispatchType);
   m_uniqueTouchEventId = event.uniqueTouchEventId;
 }
 
@@ skipping 10 matching lines @@
       convertAbsoluteLocationForLayoutObjectFloat(location, layoutItem));
 }
 
 // FIXME: Change |widget| to const Widget& after RemoteFrames get
 // RemoteFrameViews.
 static void updateWebMouseEventFromCoreMouseEvent(
     const MouseRelatedEvent& event,
     const Widget* widget,
     const LayoutItem layoutItem,
     WebMouseEvent& webEvent) {
-  webEvent.timeStampSeconds = event.platformTimeStamp();
+  webEvent.timeStampSeconds = toSeconds(event.platformTimeStamp());
   webEvent.modifiers = event.modifiers();
 
   FrameView* view = widget ? toFrameView(widget->parent()) : 0;
   // TODO(bokan): If view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame(event.absoluteLocation().x(),
                             event.absoluteLocation().y());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
   webEvent.globalX = event.screenX();
@@ skipping 82 matching lines @@
 
   if (event.type() == EventTypeNames::touchstart)
     type = MouseDown;
   else if (event.type() == EventTypeNames::touchmove)
     type = MouseMove;
   else if (event.type() == EventTypeNames::touchend)
     type = MouseUp;
   else
     return;
 
-  timeStampSeconds = event.platformTimeStamp();
+  timeStampSeconds = toSeconds(event.platformTimeStamp());
   modifiers = event.modifiers();
 
   // The mouse event co-ordinates should be generated from the co-ordinates of
   // the touch point.
   FrameView* view = toFrameView(widget->parent());
   // FIXME: if view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame = roundedIntPoint(touch->absoluteLocation());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
@@ skipping 54 matching lines @@
   if (event.type() == EventTypeNames::keydown)
     type = KeyDown;
   else if (event.type() == EventTypeNames::keyup)
     type = WebInputEvent::KeyUp;
   else if (event.type() == EventTypeNames::keypress)
     type = WebInputEvent::Char;
   else
     return;  // Skip all other keyboard events.
 
   modifiers = event.modifiers();
-  timeStampSeconds = event.platformTimeStamp();
+  timeStampSeconds = toSeconds(event.platformTimeStamp());
   windowsKeyCode = event.keyCode();
 }
 
 static WebTouchPoint toWebTouchPoint(const Touch* touch,
                                      const LayoutItem layoutItem,
                                      WebTouchPoint::State state,
                                      WebPointerProperties::PointerType type) {
   WebTouchPoint point;
   point.pointerType = type;
   point.id = touch->identifier();
@@ skipping 53 matching lines @@
   else if (event.type() == EventTypeNames::touchend)
     type = TouchEnd;
   else if (event.type() == EventTypeNames::touchcancel)
     type = TouchCancel;
   else {
     NOTREACHED();
     type = Undefined;
     return;
   }
 
-  timeStampSeconds = event.platformTimeStamp();
+  timeStampSeconds = toSeconds(event.platformTimeStamp());
   modifiers = event.modifiers();
   dispatchType = event.cancelable() ? WebInputEvent::Blocking
                                     : WebInputEvent::EventNonBlocking;
   movedBeyondSlopRegion = event.causesScrollingIfUncanceled();
 
   // Currently touches[] is empty, add stationary points as-is.
   for (unsigned i = 0;
        i < event.touches()->length() &&
        i < static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap);
        ++i) {
@@ skipping 44 matching lines @@
     resendingPluginId = event.resendingPluginId();
   } else if (event.type() == EventTypeNames::gestureflingstart) {
     type = GestureFlingStart;
     data.flingStart.velocityX = event.velocityX();
     data.flingStart.velocityY = event.velocityY();
   } else if (event.type() == EventTypeNames::gesturetap) {
     type = GestureTap;
     data.tap.tapCount = 1;
   }
 
-  timeStampSeconds = event.platformTimeStamp();
+  timeStampSeconds = toSeconds(event.platformTimeStamp());
   modifiers = event.modifiers();
 
   globalX = event.screenX();
   globalY = event.screenY();
   IntPoint localPoint = convertAbsoluteLocationForLayoutObjectInt(
       event.absoluteLocation(), layoutItem);
   x = localPoint.x();
   y = localPoint.y();
 
   switch (event.source()) {
@@ skipping 26 matching lines @@
   Vector<PlatformTouchEvent> result;
   for (const auto& event : coalescedEvents) {
     DCHECK(WebInputEvent::isTouchEventType(event->type));
     result.append(PlatformTouchEventBuilder(
         widget, static_cast<const WebTouchEvent&>(*event)));
   }
   return result;
 }
 
 }  // namespace blink