Use a TickClock instead of TimeTicks::Now() in Timer.

base/timer/timer.h

 // Copyright (c) 2012 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.
 
 // OneShotTimer and RepeatingTimer provide a simple timer API.  As the names
 // suggest, OneShotTimer calls you back once after a time delay expires.
 // RepeatingTimer on the other hand calls you back periodically with the
 // prescribed time interval.
 //
 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of
@@ skipping 31 matching lines @@
 // NOTE: These APIs are not thread safe. Always call from the same thread.
 
 #ifndef BASE_TIMER_TIMER_H_
 #define BASE_TIMER_TIMER_H_
 
 // IMPORTANT: If you change timer code, make sure that all tests (including
 // disabled ones) from timer_unittests.cc pass locally. Some are disabled
 // because they're flaky on the buildbot, but when you run them locally you
 // should be able to tell the difference.
 
+#include <memory>
+
 #include "base/base_export.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class BaseTimerTaskInternal;
 class SingleThreadTaskRunner;
+class TickClock;
 
 //-----------------------------------------------------------------------------
 // This class wraps MessageLoop::PostDelayedTask to manage delayed and repeating
 // tasks. It must be destructed on the same thread that starts tasks. There are
 // DCHECKs in place to verify this.
 //
 class BASE_EXPORT Timer {
  public:
   // Construct a timer in repeating or one-shot mode. Start or SetTaskInfo must
   // be called later to set task info. |retain_user_task| determines whether the
@@ skipping 12 matching lines @@
   virtual bool IsRunning() const;
 
   // Returns the current delay for this timer.
   virtual TimeDelta GetCurrentDelay() const;
 
   // Set the task runner on which the task should be scheduled. This method can
   // only be called before any tasks have been scheduled. The task runner must
   // run tasks on the same thread the timer is used on.
   virtual void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner);
 
+  // Sets the tick clock used to calculate the run time for scheduled tasks.
+  virtual void SetTickClock(std::unique_ptr<TickClock> tick_clock);

[danakj, 2016/11/09 19:57:38]

This class being virtual means subclasses need to use the tick clock too.

Here's one example I found through codesearch:
https://cs.chromium.org/chromium/src/components/timers/alarm_timer_chromeos.c...

How can we help ensure subclasses do the right thing?

Here's one idea:
1. Add a protected pure-virtual-but-implemented method Now() that calls
TimeTicks::Now(). (looks like "virtual base::TimeTicks Now() = 0;" and a defn of
that in the .cc file)
2. Subclasses will not compile without making a definition of Now() themselves.
Production can call the base class (and convert direct calls to TimeTicks::Now()
to "Now()" in the process. Tests can do whatever they like.

What do you think?

[jameswest, 2016/11/10 00:26:05]

I'm fine with that idea, but it's currently possible to instantiate Timer
directly because it doesn't have any pure virtual methods. If we add the pure
virtual method, that will no longer be possible. I don't think anything directly
instantiates Timer other than its unit tests, but are we OK with requiring only
subclasses be used?

+
   // Start the timer to run at the given |delay| from now. If the timer is
   // already running, it will be replaced to call the given |user_task|.
   virtual void Start(const tracked_objects::Location& posted_from,
                      TimeDelta delay,
                      const base::Closure& user_task);
 
   // Call this method to stop and cancel the timer.  It is a no-op if the timer
   // is not running.
   virtual void Stop();
 
@@ skipping 47 matching lines @@
   }
 
   // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call
   // RunScheduledTask() at scheduled_run_time_.
   BaseTimerTaskInternal* scheduled_task_;
 
   // The task runner on which the task should be scheduled. If it is null, the
   // task runner for the current thread should be used.
   scoped_refptr<SingleThreadTaskRunner> task_runner_;
 
+  // The tick clock used to calculate the run time for scheduled tasks.
+  std::unique_ptr<TickClock> tick_clock_;
+
   // Location in user code.
   tracked_objects::Location posted_from_;
   // Delay requested by user.
   TimeDelta delay_;
   // user_task_ is what the user wants to be run at desired_run_time_.
   base::Closure user_task_;
 
   // The estimated time that the MessageLoop will run the scheduled_task_ that
   // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the
   // task must be run immediately.
@@ skipping 97 matching lines @@
 // to link in MSVC. But clang-plugin does not allow inline definitions of
 // virtual methods, so the inline definition lives in the header file here
 // to satisfy both.
 inline void DelayTimer::Reset() {
   Timer::Reset();
 }
 
 }  // namespace base
 
 #endif  // BASE_TIMER_TIMER_H_