Remove cc::OrderedSimpleTaskRunner in DeadlineTaskRunner tests.

Bug: 841735
Change-Id: I0c385ce6bdd147b859a553e0bcf820adf379fd71
Reviewed-on: https://chromium-review.googlesource.com/1092742Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Commit-Queue: Greg Kraynov <kraynov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565616}

third_party/blink/renderer/platform/scheduler/main_thread/deadline_task_runner_unittest.cc

@@ -6,8 +6,8 @@
 
 #include <memory>
 
-#include "base/test/simple_test_tick_clock.h"
-#include "components/viz/test/ordered_simple_task_runner.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/time/tick_clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -16,86 +16,88 @@ namespace scheduler {
 
 class DeadlineTaskRunnerTest : public testing::Test {
  public:
-  DeadlineTaskRunnerTest() = default;
+  DeadlineTaskRunnerTest()
+      : task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
+            base::test::ScopedTaskEnvironment::ExecutionMode::QUEUED) {
+    // Null clock might trigger some assertions.
+    task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(5));
+  }
   ~DeadlineTaskRunnerTest() override = default;
 
   void SetUp() override {
-    clock_.reset(new base::SimpleTestTickClock());
-    clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
-    mock_task_runner_ = new cc::OrderedSimpleTaskRunner(clock_.get(), true);
     deadline_task_runner_.reset(new DeadlineTaskRunner(
         base::BindRepeating(&DeadlineTaskRunnerTest::TestTask,
                             base::Unretained(this)),
-        mock_task_runner_));
+        task_environment_.GetMainThreadTaskRunner()));
     run_times_.clear();
   }
 
-  bool RunUntilIdle() { return mock_task_runner_->RunUntilIdle(); }
+  base::TimeTicks Now() {
+    return task_environment_.GetMockTickClock()->NowTicks();
+  }
 
-  void TestTask() { run_times_.push_back(clock_->NowTicks()); }
+  void TestTask() { run_times_.push_back(Now()); }
 
-  std::unique_ptr<base::SimpleTestTickClock> clock_;
-  scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
+  base::test::ScopedTaskEnvironment task_environment_;
   std::unique_ptr<DeadlineTaskRunner> deadline_task_runner_;
   std::vector<base::TimeTicks> run_times_;
 };
 
 TEST_F(DeadlineTaskRunnerTest, RunOnce) {
-  base::TimeTicks start_time = clock_->NowTicks();
+  base::TimeTicks start_time = Now();
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay, clock_->NowTicks());
-  RunUntilIdle();
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay, Now());
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay));
 };
 
 TEST_F(DeadlineTaskRunnerTest, RunTwice) {
   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10);
-  base::TimeTicks deadline1 = clock_->NowTicks() + delay1;
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay1, clock_->NowTicks());
-  RunUntilIdle();
+  base::TimeTicks deadline1 = Now() + delay1;
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay1, Now());
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(100);
-  base::TimeTicks deadline2 = clock_->NowTicks() + delay2;
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay2, clock_->NowTicks());
-  RunUntilIdle();
+  base::TimeTicks deadline2 = Now() + delay2;
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay2, Now());
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   EXPECT_THAT(run_times_, testing::ElementsAre(deadline1, deadline2));
 };
 
 TEST_F(DeadlineTaskRunnerTest, EarlierDeadlinesTakePrecidence) {
-  base::TimeTicks start_time = clock_->NowTicks();
+  base::TimeTicks start_time = Now();
   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(1);
   base::TimeDelta delay10 = base::TimeDelta::FromMilliseconds(10);
   base::TimeDelta delay100 = base::TimeDelta::FromMilliseconds(100);
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay100, clock_->NowTicks());
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay10, clock_->NowTicks());
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay1, clock_->NowTicks());
-
-  RunUntilIdle();
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay100, Now());
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay10, Now());
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay1, Now());
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay1));
 };
 
 TEST_F(DeadlineTaskRunnerTest, LaterDeadlinesIgnored) {
-  base::TimeTicks start_time = clock_->NowTicks();
+  base::TimeTicks start_time = Now();
   base::TimeDelta delay100 = base::TimeDelta::FromMilliseconds(100);
   base::TimeDelta delay10000 = base::TimeDelta::FromMilliseconds(10000);
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay100, clock_->NowTicks());
-  deadline_task_runner_->SetDeadline(FROM_HERE, delay10000, clock_->NowTicks());
-
-  RunUntilIdle();
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay100, Now());
+  deadline_task_runner_->SetDeadline(FROM_HERE, delay10000, Now());
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay100));
 };
 
 TEST_F(DeadlineTaskRunnerTest, DeleteDeadlineTaskRunnerAfterPosting) {
   deadline_task_runner_->SetDeadline(
-      FROM_HERE, base::TimeDelta::FromMilliseconds(10), clock_->NowTicks());
+      FROM_HERE, base::TimeDelta::FromMilliseconds(10), Now());
 
   // Deleting the pending task should cancel it.
   deadline_task_runner_.reset(nullptr);
-  RunUntilIdle();
+  task_environment_.FastForwardUntilNoTasksRemain();
 
   EXPECT_TRUE(run_times_.empty());
 };