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

ui/events/test/event_generator.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/test/event_generator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 87 matching lines @@
     set_flags(flags);
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int touch_id,
                  int flags,
-                 base::TimeDelta timestamp)
+                 base::TimeTicks timestamp)
       : TouchEvent(type,
                    root_location,
                    flags,
                    touch_id,
                    timestamp,
                    1.0f,
                    1.0f,
                    0.0f,
                    0.0f) {}
 
@@ skipping 96 matching lines @@
                          ui::EventTimeForNow(), flags_, 0);
   Dispatch(&mouseev);
 }
 
 void EventGenerator::MoveMouseToWithNative(const gfx::Point& point_in_host,
                                            const gfx::Point& point_for_native) {
 #if defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitMotionEvent(point_in_host, point_for_native, flags_);
   static_cast<XEvent*>(xevent)->xmotion.time =
-      Now().InMilliseconds() & UINT32_MAX;
+      (Now() - base::TimeTicks()).InMilliseconds() & UINT32_MAX;
   ui::MouseEvent mouseev(xevent);
 #elif defined(USE_OZONE)
   // Ozone uses the location in native event as a system location.
   // Create a fake event with the point in host, which will be passed
   // to the non native event, then update the native event with the native
   // (root) one.
   std::unique_ptr<ui::MouseEvent> native_event(new ui::MouseEvent(
       ui::ET_MOUSE_MOVED, point_in_host, point_in_host, Now(), flags_, 0));
   ui::MouseEvent mouseev(native_event.get());
   native_event->set_location(point_for_native);
@@ skipping 158 matching lines @@
                                     base::Bind(&DummyCallback));
 }
 
 void EventGenerator::GestureScrollSequenceWithCallback(
     const gfx::Point& start,
     const gfx::Point& end,
     const base::TimeDelta& step_delay,
     int steps,
     const ScrollStepCallback& callback) {
   const int kTouchId = 5;
-  base::TimeDelta timestamp = Now();
+  base::TimeTicks timestamp = Now();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, 0, kTouchId,
                        timestamp, 5.0f, 5.0f, 0.0f, 1.0f);
   Dispatch(&press);
 
   callback.Run(ui::ET_GESTURE_SCROLL_BEGIN, gfx::Vector2dF());
 
   float dx = static_cast<float>(end.x() - start.x()) / steps;
   float dy = static_cast<float>(end.y() - start.y()) / steps;
   gfx::PointF location(start);
   for (int i = 0; i < steps; ++i) {
@@ skipping 39 matching lines @@
   CHECK_LE(count, kMaxTouchPoints);
   CHECK_GT(steps, 0);
 
   int delta_x = move_x / steps;
   int delta_y = move_y / steps;
 
   for (int i = 0; i < count; ++i) {
     points[i] = start[i];
   }
 
-  base::TimeDelta press_time_first = Now();
-  base::TimeDelta press_time[kMaxTouchPoints];
+  base::TimeTicks press_time_first = Now();
+  base::TimeTicks press_time[kMaxTouchPoints];
   bool pressed[kMaxTouchPoints];
   for (int i = 0; i < count; ++i) {
     pressed[i] = false;
     press_time[i] = press_time_first +
         base::TimeDelta::FromMilliseconds(delay_adding_finger_ms[i]);
   }
 
   int last_id = 0;
   for (int step = 0; step < steps; ++step) {
-    base::TimeDelta move_time = press_time_first +
+    base::TimeTicks move_time =
+        press_time_first +
         base::TimeDelta::FromMilliseconds(event_separation_time_ms * step);
 
     while (last_id < count &&
            !pressed[last_id] &&
            move_time >= press_time[last_id]) {
       ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                            points[last_id],
                            last_id,
                            press_time[last_id]);
       Dispatch(&press);
       pressed[last_id] = true;
       last_id++;
     }
 
     for (int i = 0; i < count; ++i) {
       points[i].Offset(delta_x, delta_y);
       if (i >= last_id)
         continue;
       ui::TouchEvent move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
       Dispatch(&move);
     }
   }
 
-  base::TimeDelta release_time = press_time_first +
+  base::TimeTicks release_time =
+      press_time_first +
       base::TimeDelta::FromMilliseconds(event_separation_time_ms * steps);
   for (int i = 0; i < last_id; ++i) {
     ui::TouchEvent release(
         ui::ET_TOUCH_RELEASED, points[i], i, release_time);
     Dispatch(&release);
   }
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     float x_offset,
                                     float y_offset,
                                     int steps,
                                     int num_fingers) {
-  base::TimeDelta timestamp = Now();
+  base::TimeTicks timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   float dx = x_offset / steps;
@@ skipping 18 matching lines @@
                               x_offset, y_offset,
                               num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     const std::vector<gfx::PointF>& offsets,
                                     int num_fingers) {
   size_t steps = offsets.size();
-  base::TimeDelta timestamp = Now();
+  base::TimeTicks timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   for (size_t i = 0; i < steps; ++i) {
@@ skipping 32 matching lines @@
 
 void EventGenerator::SetTickClock(std::unique_ptr<base::TickClock> tick_clock) {
   scoped_refptr<ClonableTickClock> clonable =
       new ClonableTickClock(std::move(tick_clock));
 #if defined(USE_X11)
   ResetTimestampRolloverCountersForTesting(clonable->Clone());
 #endif
   tick_clock_ = clonable->Clone();
 }
 
-base::TimeDelta EventGenerator::Now() {
+base::TimeTicks EventGenerator::Now() {
   // This is the same as what EventTimeForNow() does, but here we do it
   // with a tick clock that can be replaced with a simulated clock for tests.
-  return base::TimeDelta::FromInternalValue(
-      tick_clock_->NowTicks().ToInternalValue());
+  return tick_clock_->NowTicks();
 }
 
 void EventGenerator::Init(gfx::NativeWindow root_window,
                           gfx::NativeWindow window_context) {
   SetTickClock(WrapUnique(new TestTickClock()));
   delegate()->SetContext(this, root_window, window_context);
   if (window_context)
     current_location_ = delegate()->CenterOfWindow(window_context);
   current_target_ = delegate()->GetTargetAt(current_location_);
 }
 
 void EventGenerator::DispatchKeyEvent(bool is_press,
                                       ui::KeyboardCode key_code,
                                       int flags) {
 #if defined(OS_WIN)
   UINT key_press = WM_KEYDOWN;
   uint16_t character = ui::DomCodeToUsLayoutCharacter(
       ui::UsLayoutKeyboardCodeToDomCode(key_code), flags);
   if (is_press && character) {
     MSG native_event = { NULL, WM_KEYDOWN, key_code, 0 };
     TestKeyEvent keyev(native_event, flags);
     Dispatch(&keyev);
     // On Windows, WM_KEYDOWN event is followed by WM_CHAR with a character
     // if the key event cooresponds to a real character.
     key_press = WM_CHAR;
     key_code = static_cast<ui::KeyboardCode>(character);
   }
   MSG native_event =
       { NULL, (is_press ? key_press : WM_KEYUP), key_code, 0 };
-  native_event.time = Now().InMicroseconds();
+  native_event.time = (Now() - base::TimeTicks()).InMicroseconds();
   TestKeyEvent keyev(native_event, flags);
 #elif defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitKeyEvent(is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
                       key_code,
                       flags);
-  static_cast<XEvent*>(xevent)->xkey.time = Now().InMilliseconds() & UINT32_MAX;
+  static_cast<XEvent*>(xevent)->xkey.time =
+      (Now() - base::TimeTicks()).InMilliseconds() & UINT32_MAX;
   ui::KeyEvent keyev(xevent);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
   ui::KeyEvent keyev(type, key_code, flags);
 #endif  // OS_WIN
   Dispatch(&keyev);
 }
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
   current_target_ = delegate()->GetTargetAt(point);
@@ skipping 76 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui