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

base/test/test_mock_time_task_runner.cc

 // 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.
 
 #include "base/test/test_mock_time_task_runner.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/time/clock.h"
+#include "base/time/tick_clock.h"
 
 namespace base {
 
 namespace {
 
-// TickClock that always returns the then-current mock time of |task_runner| as
-// the current time.
+// MockTickClock --------------------------------------------------------------
+
+// TickClock that always returns the then-current mock time ticks of
+// |task_runner| as the current time ticks.
 class MockTickClock : public TickClock {
  public:
   explicit MockTickClock(
       scoped_refptr<const TestMockTimeTaskRunner> task_runner);
   ~MockTickClock() override;
 
   // TickClock:
   TimeTicks NowTicks() override;
 
  private:
   scoped_refptr<const TestMockTimeTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTickClock);
 };
 
 MockTickClock::MockTickClock(
     scoped_refptr<const TestMockTimeTaskRunner> task_runner)
     : task_runner_(task_runner) {
 }
 
 MockTickClock::~MockTickClock() {
 }
 
 TimeTicks MockTickClock::NowTicks() {
-  return task_runner_->GetCurrentMockTime();
+  return task_runner_->NowTicks();
+}
+
+// MockClock ------------------------------------------------------------------
+
+// Clock that always returns the then-current mock time of |task_runner| as the
+// current time.
+class MockClock : public Clock {
+ public:
+  explicit MockClock(scoped_refptr<const TestMockTimeTaskRunner> task_runner);
+  ~MockClock() override;
+
+  // Clock:
+  Time Now() override;
+
+ private:
+  scoped_refptr<const TestMockTimeTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockClock);
+};
+
+MockClock::MockClock(scoped_refptr<const TestMockTimeTaskRunner> task_runner)
+    : task_runner_(task_runner) {
+}
+
+MockClock::~MockClock() {
+}
+
+Time MockClock::Now() {
+  return task_runner_->Now();
 }
 
 }  // namespace
 
+// TestMockTimeTaskRunner -----------------------------------------------------
+
 bool TestMockTimeTaskRunner::TemporalOrder::operator()(
     const TestPendingTask& first_task,
     const TestPendingTask& second_task) const {
   return first_task.GetTimeToRun() > second_task.GetTimeToRun();
 }
 
-TestMockTimeTaskRunner::TestMockTimeTaskRunner() {
+TestMockTimeTaskRunner::TestMockTimeTaskRunner() : now_(Time::UnixEpoch()) {
+}
+
+TestMockTimeTaskRunner::TestMockTimeTaskRunner(Time intial_time)

[Lei Zhang, 2015/02/04 20:27:37]

typo

[engedy, 2015/02/05 10:22:57]

Removed ctor, thanks for spotting the typo, though!

+    : now_(intial_time) {
 }
 
 TestMockTimeTaskRunner::~TestMockTimeTaskRunner() {
 }
 
 void TestMockTimeTaskRunner::FastForwardBy(TimeDelta delta) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   OnBeforeSelectingTask();
 
-  const base::TimeTicks original_now = now_;
+  const TimeTicks original_now_ticks = now_ticks_;
   TestPendingTask task_info;
-  while (DequeueNextTask(original_now, delta, &task_info)) {
-    if (task_info.GetTimeToRun() - now_ > base::TimeDelta()) {
-      now_ = task_info.GetTimeToRun();
-      OnAfterTimePassed();
-    }
-
+  while (DequeueNextTask(original_now_ticks, delta, &task_info)) {
+    ForwardClocksUntilTickTime(task_info.GetTimeToRun());
     task_info.task.Run();
-
     OnAfterTaskRun();
     OnBeforeSelectingTask();
   }
 
-  if (!delta.is_max() && now_ - original_now < delta) {
-    now_ = original_now + delta;

[Lei Zhang, 2015/02/04 20:27:37]

Just trying to understand the original code here... Isn't it possible for |now_|
to overflow here, causing the time to go backwards? Is the delta.is_max() check
suppose to detect overflow?

[engedy, 2015/02/05 10:22:57]

You are correct: it has been, and it is still possible for the time to overflow.
I can be convinced otherwise, but I am leaning towards  thinking that it should
be up to the consumer to make sure this does not happen -- I have added the
sufficient condition for achieving this to the class comment.

On the other hand, delta.is_max() was a just a big hack so this method can be
called with TimeDelta::Max() to get the implementation of
FastForwardUntilNoTasksRemain() for free. I have provided a separate
implementation without the hack.

[Lei Zhang, 2015/02/05 10:52:59]

Is is possible to have both FastForwardBy() and FastForwardUntilNoTasksRemain()
call some internal function, so you don't need 2 separate, but nearly identical
copies, and you don't need the is_max() hack?

[engedy, 2015/02/05 12:41:23]

I went with a slightly less evil version of the old solution. PTAL.

Alternatively, we could create an internal implementation that either:
  * takes a callback to evaluate the exit condition (this could be exposed to
consumers),
  * is a template that takes a functor (this could be exposed to consumers).

-    OnAfterTimePassed();
-  }
+  if (!delta.is_max())
+    ForwardClocksUntilTickTime(original_now_ticks + delta);
 }
 
 void TestMockTimeTaskRunner::RunUntilIdle() {
   FastForwardBy(TimeDelta());
 }
 
 void TestMockTimeTaskRunner::FastForwardUntilNoTasksRemain() {
   FastForwardBy(TimeDelta::Max());
 }
 
-TimeTicks TestMockTimeTaskRunner::GetCurrentMockTime() const {
+Time TestMockTimeTaskRunner::Now() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return now_;
 }
 
+TimeTicks TestMockTimeTaskRunner::NowTicks() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return now_ticks_;
+}
+
+scoped_ptr<Clock> TestMockTimeTaskRunner::GetMockClock() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return make_scoped_ptr(new MockClock(this));
+}
+
 scoped_ptr<TickClock> TestMockTimeTaskRunner::GetMockTickClock() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return make_scoped_ptr(new MockTickClock(this));
 }
 
 bool TestMockTimeTaskRunner::HasPendingTask() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !tasks_.empty();
 }
 
 size_t TestMockTimeTaskRunner::GetPendingTaskCount() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tasks_.size();
 }
 
 TimeDelta TestMockTimeTaskRunner::NextPendingTaskDelay() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return tasks_.empty() ? TimeDelta::Max() : tasks_.top().GetTimeToRun() - now_;
+  return tasks_.empty() ? TimeDelta::Max()
+                        : tasks_.top().GetTimeToRun() - now_ticks_;
 }
 
 bool TestMockTimeTaskRunner::RunsTasksOnCurrentThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 bool TestMockTimeTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
-  base::AutoLock scoped_lock(tasks_lock_);
-  tasks_.push(
-      TestPendingTask(from_here, task, now_, delay, TestPendingTask::NESTABLE));
+  AutoLock scoped_lock(tasks_lock_);
+  tasks_.push(TestPendingTask(from_here, task, now_ticks_, delay,
+                              TestPendingTask::NESTABLE));
   return true;
 }
 
 bool TestMockTimeTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   NOTREACHED();
   return false;
 }
 
 void TestMockTimeTaskRunner::OnBeforeSelectingTask() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::OnAfterTimePassed() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::OnAfterTaskRun() {
   // Empty default implementation.
 }
 
-bool TestMockTimeTaskRunner::DequeueNextTask(const base::TimeTicks& reference,
-                                             const base::TimeDelta& max_delta,
+void TestMockTimeTaskRunner::ForwardClocksUntilTickTime(TimeTicks later_ticks) {
+  now_ += later_ticks - now_ticks_;

[Lei Zhang, 2015/02/04 20:27:37]

Can this make time move backwards? In the original code, unless there's an
overflow, I think |now_| can only increase.

[engedy, 2015/02/05 10:22:57]

Hmm, yes, if the consumer of this class posts tasks with negative delays, then
time can move backwards -- this could not happen before.

I have added an explicit check here to prevent this, and pointed it out in the
comment for this method.

+  if (now_ticks_ < later_ticks) {
+    now_ticks_ = later_ticks;
+    OnAfterTimePassed();
+  }
+}
+
+bool TestMockTimeTaskRunner::DequeueNextTask(const TimeTicks& reference,
+                                             const TimeDelta& max_delta,
                                              TestPendingTask* next_task) {
-  base::AutoLock scoped_lock(tasks_lock_);
+  AutoLock scoped_lock(tasks_lock_);
   if (!tasks_.empty() &&
       (tasks_.top().GetTimeToRun() - reference) <= max_delta) {
     *next_task = tasks_.top();
     tasks_.pop();
     return true;
   }
   return false;
 }
 
 }  // namespace base