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

ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.cc

 // Copyright 2014 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/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 #include <linux/input.h>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/timer.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/event_device_util.h"
 #include "ui/events/ozone/evdev/keyboard_util_evdev.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_timer_provider.h"
@@ skipping 47 matching lines @@
 }
 
 // Callback from libgestures when a gesture is ready.
 void OnGestureReadyHelper(void* client_data, const Gesture* gesture) {
   GestureInterpreterLibevdevCros* interpreter =
       static_cast<GestureInterpreterLibevdevCros*>(client_data);
   interpreter->OnGestureReady(gesture);
 }
 
 // Convert gestures timestamp (stime_t) to ui::Event timestamp.
-base::TimeDelta StimeToTimedelta(stime_t timestamp) {
-  return base::TimeDelta::FromMicroseconds(timestamp *
-                                           base::Time::kMicrosecondsPerSecond);
+base::TimeTicks StimeToTimeTicks(stime_t timestamp) {
+  return ui::EventTimeStampFromSeconds(timestamp);

[miu, 2016/05/16 20:05:35]

Same thing here too (regarding this remaining in-line with changes to
base/time/time_posix.cc).

 }
 
 // Number of fingers for scroll gestures.
 const int kGestureScrollFingerCount = 2;
 
 // Number of fingers for swipe gestures.
 const int kGestureSwipeFingerCount = 3;
 
 }  // namespace
 
@@ skipping 173 matching lines @@
                                  move->ordinal_dx,
                                  move->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   cursor_->MoveCursor(gfx::Vector2dF(move->dx, move->dy));
   // TODO(spang): Use move->ordinal_dx, move->ordinal_dy
   dispatcher_->DispatchMouseMoveEvent(
       MouseMoveEventParams(id_, cursor_->GetLocation(),
                            PointerDetails(EventPointerType::POINTER_TYPE_MOUSE),
-                           StimeToTimedelta(gesture->end_time)));
+                           StimeToTimeTicks(gesture->end_time)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureScroll(
     const Gesture* gesture,
     const GestureScroll* scroll) {
   DVLOG(3) << base::StringPrintf("Gesture Scroll: (%f, %f) [%f, %f]",
                                  scroll->dx,
                                  scroll->dy,
                                  scroll->ordinal_dx,
                                  scroll->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   if (is_mouse_) {
     dispatcher_->DispatchMouseWheelEvent(MouseWheelEventParams(
         id_, cursor_->GetLocation(), gfx::Vector2d(scroll->dx, scroll->dy),
-        StimeToTimedelta(gesture->end_time)));
+        StimeToTimeTicks(gesture->end_time)));
   } else {
     dispatcher_->DispatchScrollEvent(ScrollEventParams(
         id_, ET_SCROLL, cursor_->GetLocation(),
         gfx::Vector2dF(scroll->dx, scroll->dy),
         gfx::Vector2dF(scroll->ordinal_dx, scroll->ordinal_dy),
-        kGestureScrollFingerCount, StimeToTimedelta(gesture->end_time)));
+        kGestureScrollFingerCount, StimeToTimeTicks(gesture->end_time)));
   }
 }
 
 void GestureInterpreterLibevdevCros::OnGestureButtonsChange(
     const Gesture* gesture,
     const GestureButtonsChange* buttons) {
   DVLOG(3) << base::StringPrintf("Gesture Button Change: down=0x%02x up=0x%02x",
                                  buttons->down,
                                  buttons->up);
 
@@ skipping 23 matching lines @@
     return;  // No cursor!
 
   EventType type =
       (fling->fling_state == GESTURES_FLING_START ? ET_SCROLL_FLING_START
                                                   : ET_SCROLL_FLING_CANCEL);
 
   // Fling is like 2-finger scrolling but with velocity instead of displacement.
   dispatcher_->DispatchScrollEvent(ScrollEventParams(
       id_, type, cursor_->GetLocation(), gfx::Vector2dF(fling->vx, fling->vy),
       gfx::Vector2dF(fling->ordinal_vx, fling->ordinal_vy),
-      kGestureScrollFingerCount, StimeToTimedelta(gesture->end_time)));
+      kGestureScrollFingerCount, StimeToTimeTicks(gesture->end_time)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipe(const Gesture* gesture,
                                                     const GestureSwipe* swipe) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe: (%f, %f) [%f, %f]",
                                  swipe->dx,
                                  swipe->dy,
                                  swipe->ordinal_dx,
                                  swipe->ordinal_dy);
 
   if (!cursor_)
     return;  // No cursor!
 
   // Swipe is 3-finger scrolling.
   dispatcher_->DispatchScrollEvent(ScrollEventParams(
       id_, ET_SCROLL, cursor_->GetLocation(),
       gfx::Vector2dF(swipe->dx, swipe->dy),
       gfx::Vector2dF(swipe->ordinal_dx, swipe->ordinal_dy),
-      kGestureSwipeFingerCount, StimeToTimedelta(gesture->end_time)));
+      kGestureSwipeFingerCount, StimeToTimeTicks(gesture->end_time)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipeLift(
     const Gesture* gesture,
     const GestureSwipeLift* swipelift) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe Lift");
 
   if (!cursor_)
     return;  // No cursor!
 
   // Turn a swipe lift into a fling start.
   // TODO(spang): Figure out why and put it in this comment.
 
   dispatcher_->DispatchScrollEvent(ScrollEventParams(
       id_, ET_SCROLL_FLING_START, cursor_->GetLocation(),
       gfx::Vector2dF() /* delta */, gfx::Vector2dF() /* ordinal_delta */,
-      kGestureScrollFingerCount, StimeToTimedelta(gesture->end_time)));
+      kGestureScrollFingerCount, StimeToTimeTicks(gesture->end_time)));
 }
 
 void GestureInterpreterLibevdevCros::OnGesturePinch(const Gesture* gesture,
                                                     const GesturePinch* pinch) {
   DVLOG(3) << base::StringPrintf(
                   "Gesture Pinch: dz=%f [%f]", pinch->dz, pinch->ordinal_dz);
 
   if (!cursor_)
     return;  // No cursor!
 
   dispatcher_->DispatchPinchEvent(
       PinchEventParams(id_, ET_GESTURE_PINCH_UPDATE, cursor_->GetLocation(),
-                       pinch->dz, StimeToTimedelta(gesture->end_time)));
+                       pinch->dz, StimeToTimeTicks(gesture->end_time)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureMetrics(
     const Gesture* gesture,
     const GestureMetrics* metrics) {
   DVLOG(3) << base::StringPrintf("Gesture Metrics: [%f, %f] type=%d",
                                  metrics->data[0],
                                  metrics->data[1],
                                  metrics->type);
 
@@ skipping 17 matching lines @@
 void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int button,
                                                          bool down,
                                                          stime_t time) {
   if (!SetMouseButtonState(button, down))
     return;  // No change.
 
   bool allow_remap = is_mouse_;
   dispatcher_->DispatchMouseButtonEvent(MouseButtonEventParams(
       id_, cursor_->GetLocation(), button, down, allow_remap,
       PointerDetails(EventPointerType::POINTER_TYPE_MOUSE),
-      StimeToTimedelta(time)));
+      StimeToTimeTicks(time)));
 }
 
 void GestureInterpreterLibevdevCros::DispatchChangedKeys(
     unsigned long* new_key_state,
     stime_t timestamp) {
   unsigned long key_state_diff[EVDEV_BITS_TO_LONGS(KEY_CNT)];
 
   // Find changed keys.
   for (unsigned long i = 0; i < arraysize(key_state_diff); ++i)
     key_state_diff[i] = new_key_state[i] ^ prev_key_state_[i];
 
   // Dispatch events for changed keys.
   for (unsigned long key = 0; key < KEY_CNT; ++key) {
     if (EvdevBitIsSet(key_state_diff, key)) {
       bool value = EvdevBitIsSet(new_key_state, key);
 
       // Mouse buttons are handled by DispatchMouseButton.
       if (key >= BTN_MOUSE && key < BTN_JOYSTICK)
         continue;
 
       // Ignore digi buttons (e.g. BTN_TOOL_FINGER).
       if (key >= BTN_DIGI && key < BTN_WHEEL)
         continue;
 
       // Dispatch key press or release to keyboard.
       dispatcher_->DispatchKeyEvent(
           KeyEventParams(id_, key, value, false /* suppress_auto_repeat */,
-                         StimeToTimedelta(timestamp)));
+                         StimeToTimeTicks(timestamp)));
     }
   }
 
   // Update internal key state.
   for (unsigned long i = 0; i < EVDEV_BITS_TO_LONGS(KEY_CNT); ++i)
     prev_key_state_[i] = new_key_state[i];
 }
 
 void GestureInterpreterLibevdevCros::ReleaseKeys(stime_t timestamp) {
   unsigned long new_key_state[EVDEV_BITS_TO_LONGS(KEY_CNT)];
@@ skipping 18 matching lines @@
 
 void GestureInterpreterLibevdevCros::ReleaseMouseButtons(stime_t timestamp) {
   DispatchMouseButton(BTN_LEFT, false /* down */, timestamp);
   DispatchMouseButton(BTN_MIDDLE, false /* down */, timestamp);
   DispatchMouseButton(BTN_RIGHT, false /* down */, timestamp);
   DispatchMouseButton(BTN_BACK, false /* down */, timestamp);
   DispatchMouseButton(BTN_FORWARD, false /* down */, timestamp);
 }
 
 }  // namespace ui