Template methods on Timer classes instead of the classes themselves.

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 11 matching lines @@
 //                    this, &MyClass::DoStuff);
 //     }
 //     void StopDoingStuff() {
 //       timer_.Stop();
 //     }
 //    private:
 //     void DoStuff() {
 //       // This method is called every second to do stuff.
 //       ...
 //     }
-//     base::RepeatingTimer<MyClass> timer_;
+//     base::RepeatingTimer timer_;
 //   };
 //
 // Both OneShotTimer and RepeatingTimer also support a Reset method, which
 // allows you to easily defer the timer event until the timer delay passes once
 // again.  So, in the above example, if 0.5 seconds have already passed,
 // calling Reset on timer_ would postpone DoStuff by another 1 second.  In
 // other words, Reset is shorthand for calling Stop and then Start again with
 // the same arguments.
 //
 // NOTE: These APIs are not thread safe. Always call from the same thread.
@@ skipping 150 matching lines @@
 
   // 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.
-template <class Receiver, bool kIsRepeating>
 class BaseTimerMethodPointer : public Timer {
  public:
-  typedef void (Receiver::*ReceiverMethod)();
-
   // 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;
 
-  BaseTimerMethodPointer() : Timer(kIsRepeating, kIsRepeating) {}
+  BaseTimerMethodPointer(bool repeats) : Timer(repeats, repeats) {}

[Nico, 2015/09/22 01:16:22]

nit: 

  enum RepeatMode { kOneShot, kRepeating };
  BaseTImerMethodPointer(RepeatMode mode) : Timer(mode == kRepeating, mode ==
kRepeating) {}

Then the calling sites below become

  OneShotTimer : BaseTImerMethodPointer(kOneShot) {}

and

  RepeatingTimer : BaseTImerMethodPointer(kRepeating) {}

which is more readable

[danakj, 2015/09/22 18:31:14]

Done.

 
   // 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|.
-  virtual void Start(const tracked_objects::Location& posted_from,
-                     TimeDelta delay,
-                     Receiver* receiver,
-                     ReceiverMethod 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.
-template <class Receiver>
-class OneShotTimer : public BaseTimerMethodPointer<Receiver, false> {};
+class OneShotTimer : public BaseTimerMethodPointer {
+ public:
+  OneShotTimer() : BaseTimerMethodPointer(false) {}
+};
 
 //-----------------------------------------------------------------------------
 // A simple, repeating timer.  See usage notes at the top of the file.
-template <class Receiver>
-class RepeatingTimer : public BaseTimerMethodPointer<Receiver, true> {};
+class RepeatingTimer : public BaseTimerMethodPointer {
+ public:
+  RepeatingTimer() : BaseTimerMethodPointer(true) {}
+};
 
 //-----------------------------------------------------------------------------
 // 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.
-template <class Receiver>
 class DelayTimer : protected Timer {
  public:
-  typedef void (Receiver::*ReceiverMethod)();
-
+  template <class Receiver>
   DelayTimer(const tracked_objects::Location& posted_from,
              TimeDelta delay,
              Receiver* receiver,
-             ReceiverMethod method)
-      : Timer(posted_from, delay,
+             void (Receiver::*method)())
+      : Timer(posted_from,
+              delay,
               base::Bind(method, base::Unretained(receiver)),
               false) {}
 
-  void Reset() override { Timer::Reset(); }
+  void Reset() override;
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_TIMER_H_