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

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 122 matching lines @@
 static const int maximumCursorSize = 128;
 
 // It's pretty unlikely that a scale of less than one would ever be used. But
 // all we really need to ensure here is that the scale isn't so small that
 // integer overflow can occur when dividing cursor sizes (limited above) by the
 // scale.
 static const double minimumCursorScale = 0.001;
 
 // The minimum amount of time an element stays active after a ShowPress
 // This is roughly 9 frames, which should be long enough to be noticeable.
-static const double minimumActiveInterval = 0.15;
+static const TimeDelta minimumActiveInterval = TimeDelta::FromSecondsD(0.15);
 
 enum NoCursorChangeType { NoCursorChange };
 
 class OptionalCursor {
  public:
   OptionalCursor(NoCursorChangeType) : m_isCursorChange(false) {}
   OptionalCursor(const Cursor& cursor)
       : m_isCursorChange(true), m_cursor(cursor) {}
 
   bool isCursorChange() const { return m_isCursorChange; }
@@ skipping 1503 matching lines @@
     const PlatformGestureEvent& gestureEvent,
     bool readOnly) {
   TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
   ASSERT(m_frame == m_frame->localFrameRoot());
   // Scrolling events get hit tested per frame (like wheel events do).
   ASSERT(!gestureEvent.isScrollEvent());
 
   HitTestRequest::HitTestRequestType hitType =
       m_gestureManager->getHitTypeForGestureType(gestureEvent.type());
-  double activeInterval = 0;
+  TimeDelta activeInterval;
   bool shouldKeepActiveForMinInterval = false;
   if (readOnly) {
     hitType |= HitTestRequest::ReadOnly;
   } else if (gestureEvent.type() == PlatformEvent::GestureTap) {
     // If the Tap is received very shortly after ShowPress, we want to
     // delay clearing of the active state so that it's visible to the user
     // for at least a couple of frames.
-    activeInterval = WTF::monotonicallyIncreasingTime() -
-                     m_gestureManager->getLastShowPressTimestamp();
+    activeInterval =
+        TimeTicks::Now() - m_gestureManager->getLastShowPressTimestamp();
     shouldKeepActiveForMinInterval =
-        m_gestureManager->getLastShowPressTimestamp() &&
+        !m_gestureManager->getLastShowPressTimestamp().isNull() &&
         activeInterval < minimumActiveInterval;
     if (shouldKeepActiveForMinInterval)
       hitType |= HitTestRequest::ReadOnly;
   }
 
   GestureEventWithHitTestResults eventWithHitTestResults =
       hitTestResultForGestureEvent(gestureEvent, hitType);
   // Now apply hover/active state to the final target.
   HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
   if (!request.readOnly())
     updateGestureHoverActiveState(
         request, eventWithHitTestResults.hitTestResult().innerElement());
 
   if (shouldKeepActiveForMinInterval) {
     m_lastDeferredTapElement =
         eventWithHitTestResults.hitTestResult().innerElement();
     // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
-    m_activeIntervalTimer.startOneShot(minimumActiveInterval - activeInterval,
-                                       BLINK_FROM_HERE);
+    m_activeIntervalTimer.startOneShot(
+        (minimumActiveInterval - activeInterval).InSecondsF(), BLINK_FROM_HERE);
   }
 
   return eventWithHitTestResults;
 }
 
 GestureEventWithHitTestResults EventHandler::hitTestResultForGestureEvent(
     const PlatformGestureEvent& gestureEvent,
     HitTestRequest::HitTestRequestType hitType) {
   // Perform the rect-based hit-test (or point-based if adjustment is disabled).
   // Note that we don't yet apply hover/active state here because we need to
@@ skipping 181 matching lines @@
   // The contextmenu event is a mouse event even when invoked using the
   // keyboard.  This is required for web compatibility.
   PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
   if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
     eventType = PlatformEvent::MouseReleased;
 
   PlatformMouseEvent mouseEvent(
       locationInRootFrame, globalPosition,
       WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
       PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
-      WTF::monotonicallyIncreasingTime(),
-      WebPointerProperties::PointerType::Mouse);
+      TimeTicks::Now(), WebPointerProperties::PointerType::Mouse);
 
   return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
 void EventHandler::scheduleHoverStateUpdate() {
   // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!m_hoverTimer.isActive())
     m_hoverTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
@@ skipping 218 matching lines @@
 }
 
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink