Add support in TestMockTimeTaskRunner for vending out mock Time and mock Clocks.

base/test/test_mock_time_task_runner.h

 // Copyright 2015 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.
 
 #ifndef BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_
 #define BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_
 
 #include <queue>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_pending_task.h"
 #include "base/threading/thread_checker.h"
-#include "base/time/tick_clock.h"
 #include "base/time/time.h"
 
 namespace base {
 
+class Clock;
+class TickClock;
+
 // Runs pending tasks in the order of the tasks' post time + delay, and keeps
 // track of a mock (virtual) tick clock time that can be fast-forwarded.
 //
 // TestMockTimeTaskRunner has the following properties:
 //
 //   - Methods RunsTasksOnCurrentThread() and Post[Delayed]Task() can be called
 //     from any thread, but the rest of the methods must be called on the same
 //     thread the TaskRunner was created on.
 //   - It allows for reentrancy, in that it handles the running of tasks that in
 //     turn call back into it (e.g., to post more tasks).
 //   - Tasks are stored in a priority queue, and executed in the increasing
 //     order of post time + delay.
+//   - It does not check for overflow when doing time arithmetics. A sufficient
+//     condition for preventing overflows is to make sure that the sum of all
+//     posted task delays and fast-forward increments is still representable by
+//     a TimeDelta, and that adding this delta to the starting values of Time
+//     and TickTime is still within their respective range.
 //   - Non-nestable tasks are not supported.
 //   - Tasks aren't guaranteed to be destroyed immediately after they're run.
 //
 // This is a slightly more sophisticated version of TestSimpleTaskRunner, in
 // that it supports running delayed tasks in the correct temporal order.
-class TestMockTimeTaskRunner : public base::SingleThreadTaskRunner {
+class TestMockTimeTaskRunner : public SingleThreadTaskRunner {
  public:
+  // Constructs an instance whose virtual time will start at the Unix epoch, and
+  // whose time ticks will still start at zero.
   TestMockTimeTaskRunner();
 
-  // Fast-forwards virtual time by |delta|, causing all tasks with a remaining
-  // delay less than or equal to |delta| to be executed.
-  void FastForwardBy(base::TimeDelta delta);
+  // Fast-forwards virtual time by |delta| >= 0, causing all tasks with a
+  // remaining delay less than or equal to |delta| to be executed.
+  void FastForwardBy(TimeDelta delta);
 
   // Fast-forwards virtual time just until all tasks are executed.
   void FastForwardUntilNoTasksRemain();
 
   // Executes all tasks that have no remaining delay. Tasks with a remaining
   // delay greater than zero will remain enqueued, and no virtual time will
   // elapse.
   void RunUntilIdle();
 
-  // Returns the current virtual time.
-  TimeTicks GetCurrentMockTime() const;
+  // Returns the current virtual time (initially starting at the Unix epoch).
+  Time Now() const;
 
-  // Returns a TickClock that uses the mock time of |this| as its time source.
-  // The returned TickClock will hold a reference to |this|.
+  // Returns the current virtual tick time (initially starting at 0).
+  TimeTicks NowTicks() const;
+
+  // Returns a Clock that uses the virtual time of |this| as its time source.
+  // The returned Clock will hold a reference to |this|.
+  scoped_ptr<Clock> GetMockClock() const;
+
+  // Returns a TickClock that uses the virtual time ticks of |this| as its tick
+  // source. The returned TickClock will hold a reference to |this|.
   scoped_ptr<TickClock> GetMockTickClock() const;
 
   bool HasPendingTask() const;
   size_t GetPendingTaskCount() const;
   TimeDelta NextPendingTaskDelay() const;
 
   // SingleThreadTaskRunner:
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               const base::Closure& task,
-                               TimeDelta delay) override;
-  bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      TimeDelta delay) override;
+                       const Closure& task,
+                       TimeDelta delay) override;
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const Closure& task,
+                                  TimeDelta delay) override;
 
  protected:
   ~TestMockTimeTaskRunner() override;
 
   // Called before the next task to run is selected, so that subclasses have a
   // last chance to make sure all tasks are posted.
   virtual void OnBeforeSelectingTask();
 
   // Called after the current mock time has been incremented so that subclasses
   // can react to the passing of time.
   virtual void OnAfterTimePassed();
 
   // Called after each task is run so that subclasses may perform additional
   // activities, e.g., pump additional task runners.
   virtual void OnAfterTaskRun();
 
  private:
   // Predicate that defines a strict weak temporal ordering of tasks.
   class TemporalOrder {
    public:
     bool operator()(const TestPendingTask& first_task,
                     const TestPendingTask& second_task) const;
   };
 
   typedef std::priority_queue<TestPendingTask,
                               std::vector<TestPendingTask>,
                               TemporalOrder> TaskPriorityQueue;
 
+  // Core of the implementation for all flavors of fast-forward methods. Runs
+  // all tasks with a remaining delay less than or equal to |max_delta| >= 0,

[Lei Zhang, 2015/02/05 18:25:26]

nit: phrasing is still a bit weird. How about:

Given a non-negative |max_delta|, runs ...

[engedy, 2015/02/05 18:31:54]

Done. Also one place above.

+  // and moves virtual time forward as needed for each processed task. Pass in
+  // TimeDelta::Max() as |max_delta| to run all tasks.
+  void ProcessAllTasksNoLaterThan(TimeDelta max_delta);
+
+  // Forwards |now_ticks_| until it equals |later_ticks|, and forwards |now_| by
+  // the same amount. Calls OnAfterTimePassed() if |now_ticks_| < |later_ticks|.
+  // Does nothing if |later_ticks| <= |now_ticks_|.
+  void ForwardClocksUntilTickTime(TimeTicks later_ticks);
+
   // Returns the |next_task| to run if there is any with a running time that is
   // at most |reference| + |max_delta|. This additional complexity is required
   // so that |max_delta| == TimeDelta::Max() can be supported.
-  bool DequeueNextTask(const base::TimeTicks& reference,
-                       const base::TimeDelta& max_delta,
+  bool DequeueNextTask(const TimeTicks& reference,
+                       const TimeDelta& max_delta,
                        TestPendingTask* next_task);
 
-  base::ThreadChecker thread_checker_;
-  base::TimeTicks now_;
+  ThreadChecker thread_checker_;
+  Time now_;
+  TimeTicks now_ticks_;
 
   // Temporally ordered heap of pending tasks. Must only be accessed while the
   // |tasks_lock_| is held.
   TaskPriorityQueue tasks_;
-  base::Lock tasks_lock_;
+  Lock tasks_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMockTimeTaskRunner);
 };
 
 }  // namespace base
 
 #endif  // BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_