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

base/test/test_mock_time_task_runner.h

Index: base/test/test_mock_time_task_runner.h
diff --git a/base/test/test_mock_time_task_runner.h b/base/test/test_mock_time_task_runner.h
index 2f59892b6d58d5abe943e5e5dbc5d0aee3471e3a..00d4a6b0387e0685ebee2d4ddce81196149d205c 100644
--- a/base/test/test_mock_time_task_runner.h
+++ b/base/test/test_mock_time_task_runner.h
@@ -14,11 +14,13 @@
 #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.
 //
@@ -31,18 +33,26 @@ namespace base {
 //     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

[bartfab (slow), 2015/02/12 09:50:55]

As a side note: I do not believe any part of our code cares about time
overflows. The Time* classes are meant for dealing with real time on a human
lifetime scale. Values in the range of centuries and beyond will not overflow
Time*. No test should ever need to advance time by 10^20 years or some such.

[engedy, 2015/02/12 11:27:03]

I agree, but Lei was concerned about the topic.

+//     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.

[bartfab (slow), 2015/02/12 09:50:55]

Starting at zero is problematic. Zero is a special magic value that is often
used to mean "not initialized." There is even an TimeTicks::is_null() to test
for it.

This design of Time and TimeTicks is bad of course - arithmetic with real times
can always produce a zero, inadvertently making is_null() return true from now
on. Changing the fundamental design of Time and TimeTicks would be a large
endeavor. The least we can do to work around it is to start with a non-zero
TimeTicks.

[engedy, 2015/02/12 11:27:03]

Done.

[engedy, 2015/02/13 13:07:49]

I needed to revert this change, some tests depend on that Ticks will start from
0. Happy to change this in a follow-up CL if you are strongly against this.
(Note, though, that this was not introduced in the current CL.)

[bartfab (slow), 2015/02/16 13:40:34]

SGTM. The correct solution is to get rid of is_null() and the magical meaning
assigned to the zero value. This is actually being discussed right now, so I
have hope that it will be fixed eventually.

[engedy, 2015/02/16 13:49:29]

Awesome, glad to hear that!

   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);
+  // delay less than or equal to |delta| to be executed. |delta| must be
+  // non-negative.
+  void FastForwardBy(TimeDelta delta);
 
   // Fast-forwards virtual time just until all tasks are executed.
   void FastForwardUntilNoTasksRemain();
@@ -52,11 +62,18 @@ class TestMockTimeTaskRunner : public base::SingleThreadTaskRunner {
   // 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 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 mock time of |this| as its time source.
-  // The returned TickClock will hold a reference to |this|.
+  // 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;
@@ -66,12 +83,11 @@ class TestMockTimeTaskRunner : public base::SingleThreadTaskRunner {
   // 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;
@@ -100,20 +116,32 @@ class TestMockTimeTaskRunner : public base::SingleThreadTaskRunner {
                               std::vector<TestPendingTask>,
                               TemporalOrder> TaskPriorityQueue;
 
+  // Core of the implementation for all flavors of fast-forward methods. Given a
+  // non-negative |max_delta|, runs all tasks with a remaining delay less than
+  // or equal to |max_delta|, and moves virtual time forward as needed for each
+  // processed task. Pass in TimeDelta::Max() as |max_delta| to run all tasks.

[bartfab (slow), 2015/02/12 09:50:55]

It looks like my use of TimeDelta::Max() to indicate "until no more tasks
remain" was called an evil hack, removed and re-added in the end? :)

[engedy, 2015/02/12 11:27:03]

Well, it has been made a wee bit less evil: the contract of FastForwardBy() is
now cleaner, as it no longer has this undocumented surprise built in for the
handling of TimeDelta::Max().

As a matter of fact, though, I believe your original code did not use this hack,
I am afraid I am responsible for that. :)

+  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|.

[bartfab (slow), 2015/02/12 09:50:55]

Nit: Could you reverse this to say "|later_ticks| > |now_ticks_|". It is easier
to parse and matches the order of variables that the next sentence uses.

[engedy, 2015/02/12 11:27:03]

Done.

+  // 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);
 };