base: add MockTimer

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 64 matching lines @@
 
   // Construct a timer with retained task info.
   Timer(const tracked_objects::Location& posted_from,
         TimeDelta delay,
         const base::Closure& user_task,
         bool is_repeating);
 
   virtual ~Timer();
 
   // Returns true if the timer is running (i.e., not stopped).
-  bool IsRunning() const {
+  virtual bool IsRunning() const {

[Mark Mentovai, 2014/03/13 15:17:34]

Do all of these need to become virtual? What about if we do more sharing of the
fields as I suggested in my comments in mock_timer.h?

[Elly Fong-Jones, 2014/03/13 15:30:09]

I could make is_running_ and delay_ protected, maybe? Otherwise since there are
no setters for them the child class needs to be able to return its own values.

[Mark Mentovai, 2014/03/13 15:48:56]

Elly Jones wrote:
We don’t make data members protected, ever. But you can have protected helper
methods that operate on private data.

It looks like you can get rid of the mock class’ copies of delay_ and user_task_
altogether. Just remove GetCurrentDelay, Start, and Stop. The base class’
implementations are appropriate as-is, and you can remove the “virtual” from
both of those. In Fire(), you can access the base user_task_ via the public
user_task() getter.

is_running_ is a bit trickier. I think that you can share the base class’ copy
of is_running_ if you gave the base a protected method to deal with is_running_.
But it’s probably not worth perverting the base class in this way for just the
mock class, so I’d be inclined to leave it alone.

     return is_running_;
   }
 
   // Returns the current delay for this timer.
-  TimeDelta GetCurrentDelay() const {
+  virtual TimeDelta GetCurrentDelay() const {
     return delay_;
   }
 
   // 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|.
-  void Start(const tracked_objects::Location& posted_from,
+  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.
-  void Stop();
+  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.
-  void Reset();
+  virtual void Reset();
 
   const base::Closure& user_task() const { return user_task_; }
   const TimeTicks& desired_run_time() const { return desired_run_time_; }
 
  protected:
   // Used to initiate a new delayed task.  This has the side-effect of disabling
   // scheduled_task_ if it is non-null.
   void SetTaskInfo(const tracked_objects::Location& posted_from,
                    TimeDelta delay,
                    const base::Closure& user_task);
@@ skipping 73 matching lines @@
   // 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) {}
 
   // 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|.
-  void Start(const tracked_objects::Location& posted_from,
+  virtual void Start(const tracked_objects::Location& posted_from,
              TimeDelta delay,
              Receiver* receiver,
              ReceiverMethod 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.
@@ skipping 28 matching lines @@
       : Timer(posted_from, delay,
               base::Bind(method, base::Unretained(receiver)),
               false) {}
 
   void Reset() { Timer::Reset(); }
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_TIMER_H_