Fixing and enhancing OrderedSimpleTaskRunner to allow 100% deterministic tests.

cc/test/ordered_simple_task_runner_unittest.cc

 // Copyright 2014 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 <string>
 
 #include "base/cancelable_callback.h"
+#include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_pending_task.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#define RUN_AND_CHECK_RESULT(expected_result)  \
+  task_runner_->RunPendingTasks();             \
+  EXPECT_EQ(expected_result, executed_tasks_); \
+  executed_tasks_ = "";
+
 namespace cc {
 
 class OrderedSimpleTaskRunnerTest : public testing::Test {
  public:
   OrderedSimpleTaskRunnerTest() {
     task_runner_ = new OrderedSimpleTaskRunner;
   }
   virtual ~OrderedSimpleTaskRunnerTest() {}
 
  protected:
+  std::string executed_tasks_;
+  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
+
   void CreateAndPostTask(int task_num, base::TimeDelta delay) {
     base::Closure test_task = base::Bind(&OrderedSimpleTaskRunnerTest::Task,
                                          base::Unretained(this),
                                          task_num);
     task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
   }
 
-  void RunAndCheckResult(const std::string expected_result) {
-    task_runner_->RunPendingTasks();
-    EXPECT_EQ(expected_result, executed_tasks_);
-  }
-
  private:
-  std::string executed_tasks_;
-  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-
   void Task(int task_num) {
     if (!executed_tasks_.empty())
       executed_tasks_ += " ";
-    executed_tasks_ += base::StringPrintf("%d", task_num);
+    executed_tasks_ +=
+        base::StringPrintf("%d(%" PRId64 "ms)",
+                           task_num,
+                           task_runner_->Now().ToInternalValue() /
+                               base::Time::kMicrosecondsPerMillisecond);
   }
 
   DISALLOW_COPY_AND_ASSIGN(OrderedSimpleTaskRunnerTest);
 };
 
 TEST_F(OrderedSimpleTaskRunnerTest, BasicOrderingTest) {
   CreateAndPostTask(1, base::TimeDelta());
   CreateAndPostTask(2, base::TimeDelta());
   CreateAndPostTask(3, base::TimeDelta());
 
-  RunAndCheckResult("1 2 3");
+  RUN_AND_CHECK_RESULT("1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT("");
 }
 
-TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasks) {
+TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasksAutoNow) {
+  task_runner_->SetAdvanceNow(true);
   CreateAndPostTask(1, base::TimeDelta());
   CreateAndPostTask(2, base::TimeDelta::FromMilliseconds(15));
   CreateAndPostTask(3, base::TimeDelta());
   CreateAndPostTask(4, base::TimeDelta::FromMilliseconds(8));
 
-  RunAndCheckResult("1 3 4 2");
+  RUN_AND_CHECK_RESULT("1(0ms) 3(0ms) 4(8ms) 2(15ms)");
+  RUN_AND_CHECK_RESULT("");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasksManualNow) {
+  task_runner_->SetAdvanceNow(false);
+  CreateAndPostTask(1, base::TimeDelta());
+  CreateAndPostTask(2, base::TimeDelta::FromMilliseconds(15));
+  CreateAndPostTask(3, base::TimeDelta());
+  CreateAndPostTask(4, base::TimeDelta::FromMilliseconds(8));
+
+  RUN_AND_CHECK_RESULT("1(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT("");
+  task_runner_->SetNow(base::TimeTicks::FromInternalValue(25000));
+  RUN_AND_CHECK_RESULT("4(25ms) 2(25ms)");
+  RUN_AND_CHECK_RESULT("");
 }
 
 }  // namespace cc