Remove cc::OrderedSimpleTaskRunner in ShedulerHelper unit tests.

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

third_party/blink/renderer/platform/scheduler/common/scheduler_helper_unittest.cc

@@ -8,8 +8,8 @@
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
-#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/threading/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/scheduler/base/lazy_now.h"
@@ -50,27 +50,29 @@ void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner,
 class SchedulerHelperTest : public testing::Test {
  public:
   SchedulerHelperTest()
-      : mock_task_runner_(new cc::OrderedSimpleTaskRunner(&clock_, false)) {
+      : task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
+            base::test::ScopedTaskEnvironment::ExecutionMode::QUEUED) {
+    // Null clock triggers some assertions.
+    task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(5));
     std::unique_ptr<TaskQueueManagerForTest> task_queue_manager =
-        TaskQueueManagerForTest::Create(nullptr, mock_task_runner_, &clock_);
+        TaskQueueManagerForTest::Create(nullptr,
+                                        base::ThreadTaskRunnerHandle::Get(),
+                                        task_environment_.GetMockTickClock());
     task_queue_manager_ = task_queue_manager.get();
     scheduler_helper_ = std::make_unique<NonMainThreadSchedulerHelper>(
         std::move(task_queue_manager), nullptr);
     default_task_runner_ = scheduler_helper_->DefaultWorkerTaskQueue();
-    clock_.Advance(base::TimeDelta::FromMicroseconds(5000));
   }
 
   ~SchedulerHelperTest() override = default;
 
   void TearDown() override {
     // Check that all tests stop posting tasks.
-    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-    while (mock_task_runner_->RunUntilIdle()) {
-    }
+    task_environment_.FastForwardUntilNoTasksRemain();
+    EXPECT_EQ(0u, task_environment_.GetPendingMainThreadTaskCount());
   }
 
-  void RunUntilIdle() { mock_task_runner_->RunUntilIdle(); }
-
   template <typename E>
   static void CallForEachEnumValue(E first,
                                    E last,
@@ -82,9 +84,7 @@ class SchedulerHelperTest : public testing::Test {
   }
 
  protected:
-  base::SimpleTestTickClock clock_;
-  scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
-
+  base::test::ScopedTaskEnvironment task_environment_;
   std::unique_ptr<NonMainThreadSchedulerHelper> scheduler_helper_;
   TaskQueueManagerForTest* task_queue_manager_;  // Owned by scheduler_helper.
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
@@ -103,7 +103,7 @@ TEST_F(SchedulerHelperTest, TestPostDefaultTask) {
   default_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&AppendToVectorTestTask, &run_order, "D4"));
 
-  RunUntilIdle();
+  task_environment_.RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("D2"),
                                    std::string("D3"), std::string("D4")));
@@ -116,7 +116,7 @@ TEST_F(SchedulerHelperTest, TestRentrantTask) {
       FROM_HERE, base::BindOnce(AppendToVectorReentrantTask,
                                 base::RetainedRef(default_task_runner_),
                                 &run_order, &count, 5));
-  RunUntilIdle();
+  task_environment_.RunUntilIdle();
 
   EXPECT_THAT(run_order, testing::ElementsAre(0, 1, 2, 3, 4));
 }
@@ -137,7 +137,7 @@ TEST_F(SchedulerHelperTest, GetNumberOfPendingTasks) {
   scheduler_helper_->ControlWorkerTaskQueue()->PostTask(
       FROM_HERE, base::BindOnce(&AppendToVectorTestTask, &run_order, "C1"));
   EXPECT_EQ(3U, task_queue_manager_->PendingTasksCount());
-  RunUntilIdle();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(0U, task_queue_manager_->PendingTasksCount());
 }
 
@@ -160,7 +160,7 @@ TEST_F(SchedulerHelperTest, ObserversNotifiedFor_DefaultTaskRunner) {
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
-  RunUntilIdle();
+  task_environment_.RunUntilIdle();
 }
 
 TEST_F(SchedulerHelperTest, ObserversNotNotifiedFor_ControlTaskQueue) {
@@ -172,7 +172,7 @@ TEST_F(SchedulerHelperTest, ObserversNotNotifiedFor_ControlTaskQueue) {
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
-  RunUntilIdle();
+  task_environment_.RunUntilIdle();
 }
 
 }  // namespace scheduler_helper_unittest