Remove unnecessary mocking of TickClock for events

ui/chromeos/touch_exploration_controller_unittest.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/chromeos/touch_exploration_controller.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include "base/macros.h"
@@ skipping 158 matching lines @@
   }
 
   float GetMaxDistanceFromEdge() const {
     return touch_exploration_controller_->kMaxDistanceFromEdge;
   }
 
   float GetSlopDistanceFromEdge() const {
     return touch_exploration_controller_->kSlopDistanceFromEdge;
   }
 
-  void SetTickClockForTesting(base::TickClock* simulated_clock) {
-    touch_exploration_controller_->tick_clock_ = simulated_clock;
-  }
-
   void SetTouchAccessibilityAnchorPoint(const gfx::Point& location) {
     touch_exploration_controller_->SetTouchAccessibilityAnchorPoint(location);
   }
 
  private:
   std::unique_ptr<TouchExplorationController> touch_exploration_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
 };
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
-  TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
-    // Tests fail if time is ever 0.
-    simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
-  }
+  TouchExplorationTest() : simulated_clock_(nullptr) {}
   ~TouchExplorationTest() override {}
 
   void SetUp() override {
     if (gl::GetGLImplementation() == gl::kGLImplementationNone)
       gl::GLSurfaceTestSupport::InitializeOneOff();
     aura::test::AuraTestBase::SetUp();
     cursor_client_.reset(new aura::test::TestCursorClient(root_window()));
     root_window()->AddPreTargetHandler(&event_capturer_);
     generator_.reset(new test::EventGenerator(root_window()));
-    // The generator takes ownership of the tick clock.
-    generator_->SetTickClock(
+
+    simulated_clock_ = new base::SimpleTestTickClock();
+    // Tests fail if time is ever 0.
+    simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+    // ui takes ownership of the tick clock.
+    ui::SetEventTickClockForTesting(
         std::unique_ptr<base::TickClock>(simulated_clock_));
+
     cursor_client()->ShowCursor();
     cursor_client()->DisableMouseEvents();
   }
 
   void TearDown() override {
+    ui::SetEventTickClockForTesting(nullptr);
     root_window()->RemovePreTargetHandler(&event_capturer_);
     SwitchTouchExplorationMode(false);
     cursor_client_.reset();
     aura::test::AuraTestBase::TearDown();
   }
 
  protected:
   aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }
 
   const ScopedVector<ui::Event>& GetCapturedEvents() {
@@ skipping 50 matching lines @@
 
   void AdvanceSimulatedTimePastPotentialTapDelay() {
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
     touch_exploration_controller_->CallTapTimerNowIfRunningForTesting();
   }
 
   void SuppressVLOGs(bool suppress) {
     touch_exploration_controller_->SuppressVLOGsForTesting(suppress);
   }
 
-  void SetTickClock() {
-    touch_exploration_controller_->SetTickClockForTesting(
-        static_cast<base::TickClock*>(simulated_clock_));
-  }
-
   void SwitchTouchExplorationMode(bool on) {
     if (!on && touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset();
     } else if (on && !touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset(
           new ui::TouchExplorationControllerTestApi(
               new TouchExplorationController(root_window(), &delegate_)));
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
     }
@@ skipping 84 matching lines @@
   }
 
   float GetMaxDistanceFromEdge() const {
     return touch_exploration_controller_->GetMaxDistanceFromEdge();
   }
 
   float GetSlopDistanceFromEdge() const {
     return touch_exploration_controller_->GetSlopDistanceFromEdge();
   }
 
-  base::TimeTicks Now() {
-    // This is the same as what EventTimeForNow() does, but here we do it
-    // with our simulated clock.
-    return simulated_clock_->NowTicks();
-  }
+  base::TimeTicks Now() { return ui::EventTimeForNow(); }
 
   void SetTouchAccessibilityAnchorPoint(const gfx::Point& location) {
     touch_exploration_controller_->SetTouchAccessibilityAnchorPoint(location);
   }
 
   std::unique_ptr<test::EventGenerator> generator_;
   ui::GestureDetector::Config gesture_detector_config_;
-  // Owned by |generator_|.
+  // Owned by |ui|.
   base::SimpleTestTickClock* simulated_clock_;
   MockTouchExplorationControllerDelegate delegate_;
 
  private:
   EventCapturer event_capturer_;
   std::unique_ptr<TouchExplorationControllerTestApi>
       touch_exploration_controller_;
   std::unique_ptr<aura::test::TestCursorClient> cursor_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
@@ skipping 421 matching lines @@
   EXPECT_FALSE(IsInNoFingersDownState());
   generator_->ReleaseTouchId(3);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // Double-tapping, going into passthrough, and holding for the longpress
 // time should send a touch press and released (right click)
 // to the location of the last successful touch exploration.
 TEST_F(TouchExplorationTest, DoubleTapLongPress) {
   SwitchTouchExplorationMode(true);
-  SetTickClock();
   // Tap at one location, and get a mouse move event.
   gfx::Point tap_location(11, 12);
   generator_->set_current_location(tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
       GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
@@ skipping 964 matching lines @@
     generator_->PressTouch();
     generator_->MoveTouch(initial_press);
     generator_->MoveTouch(*point);
     generator_->ReleaseTouch();
     ASSERT_EQ(1U, delegate_.NumExitScreenSounds());
     delegate_.ResetCountersToZero();
   }
 }
 
 }  // namespace ui