Simplify base::Timer implementation

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 59 matching lines @@
 // 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
   // user_task is retained or reset when it runs or stops. If |tick_clock| is
   // provided, it is used instead of TimeTicks::Now() to get TimeTicks when
   // scheduling tasks.
-  Timer(bool retain_user_task, bool is_repeating);
-  Timer(bool retain_user_task, bool is_repeating, TickClock* tick_clock);
+  Timer(bool retain_user_task,
+        bool is_repeating,
+        TickClock* tick_clock = nullptr);
 
   // Construct a timer with retained task info. If |tick_clock| is provided, it
   // is used instead of TimeTicks::Now() to get TimeTicks when scheduling tasks.
   Timer(const tracked_objects::Location& posted_from,
         TimeDelta delay,
         const base::Closure& user_task,
-        bool is_repeating);
-  Timer(const tracked_objects::Location& posted_from,
-        TimeDelta delay,
-        const base::Closure& user_task,
         bool is_repeating,
-        TickClock* tick_clock);
+        TickClock* tick_clock = nullptr);
 
   virtual ~Timer();
 
   // Returns true if the timer is running (i.e., not stopped).
   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);
 
   // 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);
 
+  // Start the timer to run at the given |delay| from now. If the timer is
+  // already running, it will be replaced to call a task formed from
+  // |reviewer->*method|.
+  template <class Receiver>
+  void Start(const tracked_objects::Location& posted_from,
+             TimeDelta delay,
+             Receiver* receiver,
+             void (Receiver::*method)()) {
+    Timer::Start(posted_from, delay,
+                 base::Bind(method, base::Unretained(receiver)));
+  }
+
   // Call this method to stop and cancel the timer.  It is a no-op if the timer
   // is not running.
   virtual void Stop();
 
   // Call this method to reset the timer delay. The user_task_ must be set. If
   // the timer is not running, this will start it by posting a task.
   virtual void Reset();
 
   const base::Closure& user_task() const { return user_task_; }
   const TimeTicks& desired_run_time() const { return desired_run_time_; }
@@ skipping 87 matching lines @@
   // The tick clock used to calculate the run time for scheduled tasks.
   TickClock* const tick_clock_;
 
   // If true, user_task_ is scheduled to run sometime in the future.
   bool is_running_;
 
   DISALLOW_COPY_AND_ASSIGN(Timer);
 };
 
 //-----------------------------------------------------------------------------
-// This class is an implementation detail of OneShotTimer and RepeatingTimer.
-// Please do not use this class directly.
-class BaseTimerMethodPointer : public Timer {
- public:
-  // This is here to work around the fact that Timer::Start is "hidden" by the
-  // Start definition below, rather than being overloaded.
-  // TODO(tim): We should remove uses of BaseTimerMethodPointer::Start below
-  // and convert callers to use the base::Closure version in Timer::Start,
-  // see bug 148832.
-  using Timer::Start;
-
-  enum RepeatMode { ONE_SHOT, REPEATING };
-  BaseTimerMethodPointer(RepeatMode mode, TickClock* tick_clock)
-      : Timer(mode == REPEATING, mode == REPEATING, tick_clock) {}
-
-  // Start the timer to run at the given |delay| from now. If the timer is
-  // already running, it will be replaced to call a task formed from
-  // |reviewer->*method|.
-  template <class Receiver>
-  void Start(const tracked_objects::Location& posted_from,
-             TimeDelta delay,
-             Receiver* receiver,
-             void (Receiver::*method)()) {
-    Timer::Start(posted_from, delay,
-                 base::Bind(method, base::Unretained(receiver)));
-  }
-};
-
-//-----------------------------------------------------------------------------
 // A simple, one-shot timer.  See usage notes at the top of the file.
-class OneShotTimer : public BaseTimerMethodPointer {
+class OneShotTimer : public Timer {
  public:
-  OneShotTimer() : OneShotTimer(nullptr) {}
-  explicit OneShotTimer(TickClock* tick_clock)
-      : BaseTimerMethodPointer(ONE_SHOT, tick_clock) {}
+  explicit OneShotTimer(TickClock* tick_clock = nullptr)
+      : Timer(false, false, tick_clock) {}
 };
 
 //-----------------------------------------------------------------------------
 // A simple, repeating timer.  See usage notes at the top of the file.
-class RepeatingTimer : public BaseTimerMethodPointer {
+class RepeatingTimer : public Timer {
  public:
-  RepeatingTimer() : RepeatingTimer(nullptr) {}
-  explicit RepeatingTimer(TickClock* tick_clock)
-      : BaseTimerMethodPointer(REPEATING, tick_clock) {}
+  explicit RepeatingTimer(TickClock* tick_clock = nullptr)
+      : Timer(true, true, tick_clock) {}
 };
 
 //-----------------------------------------------------------------------------
 // A Delay timer is like The Button from Lost. Once started, you have to keep
 // calling Reset otherwise it will call the given method in the MessageLoop
 // thread.
 //
 // Once created, it is inactive until Reset is called. Once |delay| seconds have
 // passed since the last call to Reset, the callback is made. Once the callback
 // has been made, it's inactive until Reset is called again.
 //
 // If destroyed, the timeout is canceled and will not occur even if already
 // inflight.
-class DelayTimer : protected Timer {
+class DelayTimer {
  public:
   template <class Receiver>
   DelayTimer(const tracked_objects::Location& posted_from,
              TimeDelta delay,
              Receiver* receiver,
-             void (Receiver::*method)())
-      : DelayTimer(posted_from, delay, receiver, method, nullptr) {}
+             void (Receiver::*method)(),
+             TickClock* tick_clock = nullptr)
+      : timer_(posted_from,
+               delay,
+               base::Bind(method, base::Unretained(receiver)),
+               false,
+               tick_clock) {}
 
-  template <class Receiver>
-  DelayTimer(const tracked_objects::Location& posted_from,
-             TimeDelta delay,
-             Receiver* receiver,
-             void (Receiver::*method)(),
-             TickClock* tick_clock)
-      : Timer(posted_from,
-              delay,
-              base::Bind(method, base::Unretained(receiver)),
-              false,
-              tick_clock) {}
+  void Reset() { timer_.Reset(); }
 
-  void Reset() override;
+ private:
+  Timer timer_;
 };
 
-// This class has a templated method so it can not be exported without failing
-// 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_