Remove unnecessary mocking of TickClock for events

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 23 matching lines @@
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #endif
 
 namespace ui {
 namespace test {
 namespace {
 
 void DummyCallback(EventType, const gfx::Vector2dF&) {
 }
 
-// A proxy for TickClock that allows passing the same underlying clock
-// to multiple consumers, each retaining a unique_ptr to their own
-// instance of TickClock proxy.
-class ClonableTickClock : public base::TickClock,
-                          public base::RefCounted<ClonableTickClock> {
- private:
-  class TickClockProxy : public base::TickClock {
-   public:
-    explicit TickClockProxy(ClonableTickClock* tick_clock)
-        : tick_clock_(tick_clock) {}
-
-   private:
-    base::TimeTicks NowTicks() override { return tick_clock_->NowTicks(); }
-
-    scoped_refptr<ClonableTickClock> tick_clock_;
-    DISALLOW_COPY_AND_ASSIGN(TickClockProxy);
-  };
-
- public:
-  explicit ClonableTickClock(std::unique_ptr<base::TickClock> tick_clock)
-      : tick_clock_(std::move(tick_clock)) {}
-
-  base::TimeTicks NowTicks() override { return tick_clock_->NowTicks(); }
-  std::unique_ptr<TickClock> Clone() {
-    return WrapUnique(new TickClockProxy(this));
-  }
-
- private:
-  friend class base::RefCounted<ClonableTickClock>;
-  ~ClonableTickClock() override = default;
-  std::unique_ptr<TickClock> tick_clock_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClonableTickClock);
-};
-
 class TestTickClock : public base::TickClock {
  public:
   // Starts off with a clock set to TimeTicks().
   TestTickClock() {}
 
   base::TimeTicks NowTicks() override {
     return base::TimeTicks::FromInternalValue(ticks_++ * 1000);
   }
 
  private:
@@ skipping 118 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() - base::TimeTicks()).InMilliseconds() & UINT32_MAX;
+      (ui::EventTimeForNow() - 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));
+  std::unique_ptr<ui::MouseEvent> native_event(
+      new ui::MouseEvent(ui::ET_MOUSE_MOVED, point_in_host, point_in_host,
+                         ui::EventTimeForNow(), flags_, 0));
   ui::MouseEvent mouseev(native_event.get());
   native_event->set_location(point_for_native);
 #else
   ui::MouseEvent mouseev(ui::ET_MOUSE_MOVED, point_in_host, point_for_native,
-                         Now(), flags_, 0);
+                         ui::EventTimeForNow(), flags_, 0);
   LOG(FATAL)
       << "Generating a native motion event is not supported on this platform";
 #endif
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
   delegate()->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
@@ skipping 43 matching lines @@
 
 void EventGenerator::MoveMouseToCenterOf(EventTarget* window) {
   MoveMouseTo(CenterOfWindow(window));
 }
 
 void EventGenerator::PressTouch() {
   PressTouchId(0);
 }
 
 void EventGenerator::PressTouchId(int touch_id) {
-  TestTouchEvent touchev(
-      ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), touch_id, flags_,
-      Now());
+  TestTouchEvent touchev(ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(),
+                         touch_id, flags_, ui::EventTimeForNow());
   Dispatch(&touchev);
 }
 
 void EventGenerator::MoveTouch(const gfx::Point& point) {
   MoveTouchId(point, 0);
 }
 
 void EventGenerator::MoveTouchId(const gfx::Point& point, int touch_id) {
   current_location_ = point;
-  TestTouchEvent touchev(
-      ui::ET_TOUCH_MOVED, GetLocationInCurrentRoot(), touch_id, flags_,
-      Now());
+  TestTouchEvent touchev(ui::ET_TOUCH_MOVED, GetLocationInCurrentRoot(),
+                         touch_id, flags_, ui::EventTimeForNow());
   Dispatch(&touchev);
 
   if (!grab_)
     UpdateCurrentDispatcher(point);
 }
 
 void EventGenerator::ReleaseTouch() {
   ReleaseTouchId(0);
 }
 
 void EventGenerator::ReleaseTouchId(int touch_id) {
-  TestTouchEvent touchev(
-      ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(), touch_id, flags_,
-      Now());
+  TestTouchEvent touchev(ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(),
+                         touch_id, flags_, ui::EventTimeForNow());
   Dispatch(&touchev);
 }
 
 void EventGenerator::PressMoveAndReleaseTouchTo(const gfx::Point& point) {
   PressTouch();
   MoveTouch(point);
   ReleaseTouch();
 }
 
 void EventGenerator::PressMoveAndReleaseTouchToCenterOf(EventTarget* window) {
   PressMoveAndReleaseTouchTo(CenterOfWindow(window));
 }
 
 void EventGenerator::GestureEdgeSwipe() {
   GestureEventDetails details(ET_GESTURE_WIN8_EDGE_SWIPE);
   details.set_device_type(GestureDeviceType::DEVICE_TOUCHSCREEN);
-  GestureEvent gesture(0, 0, 0, Now(), details);
+  GestureEvent gesture(0, 0, 0, ui::EventTimeForNow(), details);
   Dispatch(&gesture);
 }
 
 void EventGenerator::GestureTapAt(const gfx::Point& location) {
   const int kTouchId = 2;
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                       location,
-                       kTouchId,
-                       Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId,
+                       ui::EventTimeForNow());
   Dispatch(&press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
   Dispatch(&release);
 }
 
 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
   const int kTouchId = 3;
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                       location,
-                       kTouchId,
-                       Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId,
+                       ui::EventTimeForNow());
   Dispatch(&press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
   Dispatch(&release);
 }
 
 base::TimeDelta EventGenerator::CalculateScrollDurationForFlingVelocity(
     const gfx::Point& start,
@@ skipping 13 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::TimeTicks timestamp = Now();
+  base::TimeTicks timestamp = ui::EventTimeForNow();
   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::TimeTicks press_time_first = Now();
+  base::TimeTicks press_time_first = ui::EventTimeForNow();
   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) {
@@ skipping 31 matching lines @@
     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::TimeTicks timestamp = Now();
+  base::TimeTicks timestamp = ui::EventTimeForNow();
   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::TimeTicks timestamp = Now();
+  base::TimeTicks timestamp = ui::EventTimeForNow();
   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 23 matching lines @@
 }
 
 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(false, key_code, flags);
 }
 
 void EventGenerator::Dispatch(ui::Event* event) {
   DoDispatchEvent(event, async_);
 }
 
-void EventGenerator::SetTickClock(std::unique_ptr<base::TickClock> tick_clock) {
-  scoped_refptr<ClonableTickClock> clonable =
-      new ClonableTickClock(std::move(tick_clock));
-  ui::SetEventTickClockForTesting(clonable->Clone());
-  tick_clock_ = clonable->Clone();
-}
-
-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.
-  // TODO(majidvp): The tick clock used by |ui::EventTimeForNow()| is now
-  // mockable so we no longer need this.
-  return tick_clock_->NowTicks();
-}
-
 void EventGenerator::Init(gfx::NativeWindow root_window,
                           gfx::NativeWindow window_context) {
-  SetTickClock(WrapUnique(new TestTickClock()));
+  ui::SetEventTickClockForTesting(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 };
     ui::KeyEvent 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() - base::TimeTicks()).InMicroseconds();
+  native_event.time =
+      (ui::EventTimeForNow() - base::TimeTicks()).InMicroseconds();
   ui::KeyEvent 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() - base::TimeTicks()).InMilliseconds() & UINT32_MAX;
+      (ui::EventTimeForNow() - 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