Use WTF::TimeDelta to specify delays on WebTaskRunner

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.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 "platform/scheduler/renderer/web_view_scheduler_impl.h"
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
@@ skipping 77 matching lines @@
   return WTF::Bind(&RunRepeatingTask, WTF::Passed(std::move(task_runner)),
                    WTF::Unretained(run_count));
 }
 
 void RunRepeatingTask(RefPtr<blink::WebTaskRunner> task_runner,
                       int* run_count) {
   ++*run_count;
   blink::WebTaskRunner* task_runner_ptr = task_runner.Get();
   task_runner_ptr->PostDelayedTask(
       BLINK_FROM_HERE, MakeRepeatingTask(std::move(task_runner), run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 }
 
 }  // namespace
 
 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInForeground) {
   web_view_scheduler_->SetPageVisible(true);
 
   int run_count = 0;
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->TimerTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);
 }
 
 TEST_F(WebViewSchedulerImplTest,
        RepeatingTimer_PageInBackgroundThenForeground) {
   web_view_scheduler_->SetPageVisible(false);
 
   int run_count = 0;
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->TimerTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);
 
   // The task queue isn't throttled at all until it's been in the background for
   // a 10 second grace period.
   clock_->Advance(base::TimeDelta::FromSeconds(10));
 
   run_count = 0;
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ skipping 15 matching lines @@
 
   std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
       web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr);
   blink::WebTaskRunner* timer_task_runner =
       web_frame_scheduler->TimerTaskRunner().Get();
 
   int run_count = 0;
   timer_task_runner->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler->TimerTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);
 
   // The task queue isn't throttled at all until it's been in the background for
   // a 10 second grace period.
   clock_->Advance(base::TimeDelta::FromSeconds(10));
 
   run_count = 0;
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ skipping 10 matching lines @@
   // due to run before the 1s period started.
 }
 
 TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) {
   web_view_scheduler_->SetPageVisible(false);
 
   int run_count = 0;
   web_frame_scheduler_->LoadingTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->LoadingTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);  // Loading tasks should not be throttled
 }
 
 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
   std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler2(
       new WebViewSchedulerImpl(nullptr, nullptr, scheduler_.get(), false));
   std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 =
       web_view_scheduler2->CreateWebFrameSchedulerImpl(nullptr);
 
   web_view_scheduler_->SetPageVisible(true);
   web_view_scheduler2->SetPageVisible(false);
 
   // Advance past the no-throttling grace period.
   clock_->Advance(base::TimeDelta::FromSeconds(10));
 
   int run_count1 = 0;
   int run_count2 = 0;
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->TimerTaskRunner(), &run_count1),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
   web_frame_scheduler2->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler2->TimerTaskRunner(), &run_count2),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count1);
   EXPECT_EQ(1, run_count2);
 }
 
 namespace {
 
 void RunVirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
                                 RefPtr<blink::WebTaskRunner> web_task_runner,
@@ skipping 25 matching lines @@
           ->MonotonicallyIncreasingVirtualTimeSeconds() *
       1000.0;
 
   web_view_scheduler_->EnableVirtualTime();
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      2.0);
+      TimeDelta::FromMilliseconds(2));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      20.0);
+      TimeDelta::FromMilliseconds(20));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      200.0);
+      TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(real_times, ElementsAre(initial_real_time, initial_real_time,
                                       initial_real_time));
   EXPECT_THAT(virtual_times_ms, ElementsAre(initial_virtual_time_ms + 2,
                                             initial_virtual_time_ms + 20,
                                             initial_virtual_time_ms + 200));
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) {
   std::vector<base::TimeTicks> real_times;
   std::vector<size_t> virtual_times_ms;
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
   size_t initial_virtual_time_ms =
       web_frame_scheduler_->TimerTaskRunner()
           ->MonotonicallyIncreasingVirtualTimeSeconds() *
       1000.0;
 
   web_view_scheduler_->EnableVirtualTime();
 
   web_frame_scheduler_->LoadingTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->LoadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      2.0);
+      TimeDelta::FromMilliseconds(2));
 
   web_frame_scheduler_->LoadingTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->LoadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      20.0);
+      TimeDelta::FromMilliseconds(20));
 
   web_frame_scheduler_->LoadingTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->LoadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      200.0);
+      TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(real_times, ElementsAre(initial_real_time, initial_real_time,
                                       initial_real_time));
   EXPECT_THAT(virtual_times_ms, ElementsAre(initial_virtual_time_ms + 2,
                                             initial_virtual_time_ms + 20,
                                             initial_virtual_time_ms + 200));
 }
 
 TEST_F(WebViewSchedulerImplTest,
        RepeatingTimer_PageInBackground_MeansNothingForVirtualTime) {
   web_view_scheduler_->EnableVirtualTime();
   web_view_scheduler_->SetPageVisible(false);
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
 
   int run_count = 0;
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->TimerTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000));
   // Virtual time means page visibility is ignored.
   EXPECT_EQ(1999, run_count);
 
   // The global tick clock has not moved, yet we ran a large number of "delayed"
   // tasks despite calling setPageVisible(false).
   EXPECT_EQ(initial_real_time, scheduler_->tick_clock()->NowTicks());
 }
 
@@ skipping 21 matching lines @@
 
   web_frame_scheduler_->TimerTaskRunner()->PostTask(
       BLINK_FROM_HERE,
       WTF::Bind(&RunOrderTask, 0, WTF::Unretained(&run_order)));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       WTF::Bind(&DelayedRunOrderTask, 1,
                 WTF::Passed(web_frame_scheduler_->TimerTaskRunner()),
                 WTF::Unretained(&run_order)),
-      2.0);
+      TimeDelta::FromMilliseconds(2));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       WTF::Bind(&DelayedRunOrderTask, 3,
                 WTF::Passed(web_frame_scheduler_->TimerTaskRunner()),
                 WTF::Unretained(&run_order)),
-      4.0);
+      TimeDelta::FromMilliseconds(4));
 
   mock_task_runner_->RunUntilIdle();
 
   // No timer tasks are allowed to run.
   EXPECT_THAT(run_order, ElementsAre());
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) {
   std::vector<int> run_order;
 
   web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
   web_view_scheduler_->EnableVirtualTime();
 
   web_frame_scheduler_->TimerTaskRunner()->PostTask(
       BLINK_FROM_HERE,
       WTF::Bind(&RunOrderTask, 0, WTF::Unretained(&run_order)));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       WTF::Bind(&DelayedRunOrderTask, 1,
                 WTF::Passed(web_frame_scheduler_->TimerTaskRunner()),
                 WTF::Unretained(&run_order)),
-      2.0);
+      TimeDelta::FromMilliseconds(2));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       WTF::Bind(&DelayedRunOrderTask, 3,
                 WTF::Passed(web_frame_scheduler_->TimerTaskRunner()),
                 WTF::Unretained(&run_order)),
-      4.0);
+      TimeDelta::FromMilliseconds(4));
 
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 1, 2, 3, 4));
 }
 
 class WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling
     : public WebViewSchedulerImplTest {
  public:
   WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling() {}
   ~WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling() override {}
 
   bool DisableBackgroundTimerThrottling() const override { return true; }
 };
 
 TEST_F(WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling,
        RepeatingTimer_PageInBackground) {
   web_view_scheduler_->SetPageVisible(false);
 
   int run_count = 0;
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeRepeatingTask(web_frame_scheduler_->TimerTaskRunner(), &run_count),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) {
   std::vector<int> run_order;
 
   web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
   web_view_scheduler_->EnableVirtualTime();
 
   std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
       web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr);
 
   web_frame_scheduler->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE, WTF::Bind(&RunOrderTask, 1, WTF::Unretained(&run_order)),
-      1);
+      TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 namespace {
 
 template <typename T>
 std::unique_ptr<WTF::Closure> MakeDeletionTask(T* obj) {
   return WTF::Bind([](T* obj) { delete obj; }, WTF::Unretained(obj));
 }
 
 }  // namespace
 
 TEST_F(WebViewSchedulerImplTest, DeleteWebFrameSchedulers_InTask) {
   for (int i = 0; i < 10; i++) {
     WebFrameSchedulerImpl* web_frame_scheduler =
         web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr).release();
     web_frame_scheduler->TimerTaskRunner()->PostDelayedTask(
-        BLINK_FROM_HERE, MakeDeletionTask(web_frame_scheduler), 1);
+        BLINK_FROM_HERE, MakeDeletionTask(web_frame_scheduler),
+        TimeDelta::FromMilliseconds(1));
   }
   mock_task_runner_->RunUntilIdle();
 }
 
 TEST_F(WebViewSchedulerImplTest, DeleteWebViewScheduler_InTask) {
   web_frame_scheduler_->TimerTaskRunner()->PostTask(
       BLINK_FROM_HERE, MakeDeletionTask(web_view_scheduler_.release()));
   mock_task_runner_->RunUntilIdle();
 }
 
 TEST_F(WebViewSchedulerImplTest, DeleteThrottledQueue_InTask) {
   web_view_scheduler_->SetPageVisible(false);
 
   // The task queue isn't throttled at all until it's been in the background for
   // a 10 second grace period.
   clock_->Advance(base::TimeDelta::FromSeconds(10));
 
   WebFrameSchedulerImpl* web_frame_scheduler =
       web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr).release();
   RefPtr<blink::WebTaskRunner> timer_task_runner =
       web_frame_scheduler->TimerTaskRunner();
 
   int run_count = 0;
   timer_task_runner->PostDelayedTask(
-      BLINK_FROM_HERE, MakeRepeatingTask(timer_task_runner, &run_count), 1.0);
+      BLINK_FROM_HERE, MakeRepeatingTask(timer_task_runner, &run_count),
+      TimeDelta::FromMilliseconds(1));
 
   // Note this will run at time t = 10s since we start at time t = 5000us, and
   // it will prevent further tasks from running (i.e. the RepeatingTask) by
   // deleting the WebFrameScheduler.
-  timer_task_runner->PostDelayedTask(
-      BLINK_FROM_HERE, MakeDeletionTask(web_frame_scheduler), 9990.0);
+  timer_task_runner->PostDelayedTask(BLINK_FROM_HERE,
+                                     MakeDeletionTask(web_frame_scheduler),
+                                     TimeDelta::FromMilliseconds(9990));
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100));
   EXPECT_EQ(10, run_count);
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTimePolicy_DETERMINISTIC_LOADING) {
   web_view_scheduler_->SetVirtualTimePolicy(
       VirtualTimePolicy::DETERMINISTIC_LOADING);
   // Initially virtual time is not allowed to advance until we have seen at
   // least one load.
@@ skipping 79 matching lines @@
   EXPECT_TRUE(web_view_scheduler_->VirtualTimeAllowedToAdvance());
 }
 
 TEST_F(WebViewSchedulerImplTest, SuspendTimersWhileVirtualTimeIsPaused) {
   std::vector<int> run_order;
 
   std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
       web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr);
   web_frame_scheduler->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE, WTF::Bind(&RunOrderTask, 1, WTF::Unretained(&run_order)),
-      0);
+      TimeDelta());
 
   web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
   web_view_scheduler_->EnableVirtualTime();
 
   mock_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTimeBudgetExhaustedCallback) {
   std::vector<base::TimeTicks> real_times;
   std::vector<size_t> virtual_times_ms;
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
   size_t initial_virtual_time_ms =
       web_frame_scheduler_->TimerTaskRunner()
           ->MonotonicallyIncreasingVirtualTimeSeconds() *
       1000.0;
 
   web_view_scheduler_->EnableVirtualTime();
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      1.0);
+      TimeDelta::FromMilliseconds(1));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      2.0);
+      TimeDelta::FromMilliseconds(2));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      5.0);
+      TimeDelta::FromMilliseconds(5));
 
   web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       MakeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->TimerTaskRunner(),
                                   &real_times, &virtual_times_ms),
-      7.0);
+      TimeDelta::FromMilliseconds(7));
 
   web_view_scheduler_->GrantVirtualTimeBudget(
       base::TimeDelta::FromMilliseconds(5),
       WTF::Bind(
           [](WebViewScheduler* scheduler) {
             scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
           },
           WTF::Unretained(web_view_scheduler_.get())));
 
   mock_task_runner_->RunUntilIdle();
@@ skipping 40 matching lines @@
   FakeWebViewSchedulerSettings web_view_scheduler_settings;
   web_view_scheduler_.reset(new WebViewSchedulerImpl(
       nullptr, &web_view_scheduler_settings, scheduler_.get(), false));
   web_frame_scheduler_ =
       web_view_scheduler_->CreateWebFrameSchedulerImpl(nullptr);
   web_view_scheduler_->SetPageVisible(false);
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(2500));
 
-  web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
-      BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
-      1);
-  web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
-      BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
-      1);
+  web_frame_scheduler_->TimerTaskRunner()
+      ->ToSingleThreadTaskRunner()
+      ->PostDelayedTask(
+          BLINK_FROM_HERE,
+          base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+          TimeDelta::FromMilliseconds(1));
+  web_frame_scheduler_->TimerTaskRunner()
+      ->ToSingleThreadTaskRunner()
+      ->PostDelayedTask(
+          BLINK_FROM_HERE,
+          base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+          TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(3500));
 
   // Check that these tasks are initially unthrottled.
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2501),
                   base::TimeTicks() + base::TimeDelta::FromMilliseconds(2751)));
   run_times.clear();
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(11500));
 
-  web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
-      BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
-      1);
-  web_frame_scheduler_->TimerTaskRunner()->PostDelayedTask(
-      BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
-      1);
+  web_frame_scheduler_->TimerTaskRunner()
+      ->ToSingleThreadTaskRunner()
+      ->PostDelayedTask(
+          BLINK_FROM_HERE,
+          base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+          TimeDelta::FromMilliseconds(1));
+  web_frame_scheduler_->TimerTaskRunner()
+      ->ToSingleThreadTaskRunner()
+      ->PostDelayedTask(
+          BLINK_FROM_HERE,
+          base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+          TimeDelta::FromMilliseconds(1));
 
   mock_task_runner_->RunUntilIdle();
 
   // After the grace period has passed, tasks should be aligned and have budget
   // based throttling.
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(12),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(26)));
 }
@@ skipping 13 matching lines @@
   std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 =
       web_view_scheduler->CreateWebFrameSchedulerImpl(nullptr);
 
   web_view_scheduler->SetPageVisible(false);
 
   // Wait for 20s to avoid initial throttling delay.
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(20500));
 
   for (size_t i = 0; i < 3; ++i) {
-    web_frame_scheduler1->TimerTaskRunner()->PostDelayedTask(
-        BLINK_FROM_HERE,
-        base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), 1);
+    web_frame_scheduler1->TimerTaskRunner()
+        ->ToSingleThreadTaskRunner()
+        ->PostDelayedTask(
+            BLINK_FROM_HERE,
+            base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+            TimeDelta::FromMilliseconds(1));
   }
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(55500));
 
   // Check that tasks are throttled.
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(21),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(26),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(51)));
   run_times.clear();
 
   std::unique_ptr<WebFrameScheduler::ActiveConnectionHandle>
       websocket_connection = web_frame_scheduler1->OnActiveConnectionCreated();
 
   for (size_t i = 0; i < 3; ++i) {
-    web_frame_scheduler1->TimerTaskRunner()->PostDelayedTask(
-        BLINK_FROM_HERE,
-        base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), 1);
+    web_frame_scheduler1->TimerTaskRunner()
+        ->ToSingleThreadTaskRunner()
+        ->PostDelayedTask(
+            BLINK_FROM_HERE,
+            base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+            TimeDelta::FromMilliseconds(1));
   }
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(58500));
 
   // Check that the timer task queue from the first frame is aligned,
   // but not throttled.
   EXPECT_THAT(
       run_times,
       ElementsAre(
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(56000),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(56250),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(56500)));
   run_times.clear();
 
   for (size_t i = 0; i < 3; ++i) {
-    web_frame_scheduler2->TimerTaskRunner()->PostDelayedTask(
-        BLINK_FROM_HERE,
-        base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), 1);
+    web_frame_scheduler2->TimerTaskRunner()
+        ->ToSingleThreadTaskRunner()
+        ->PostDelayedTask(
+            BLINK_FROM_HERE,
+            base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+            TimeDelta::FromMilliseconds(1));
   }
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(59500));
 
   // Check that the second frame scheduler becomes unthrottled.
   EXPECT_THAT(
       run_times,
       ElementsAre(
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(59000),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(59250),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(59500)));
   run_times.clear();
 
   websocket_connection.reset();
 
   // Wait for 10s to enable throttling back.
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(70500));
 
   for (size_t i = 0; i < 3; ++i) {
-    web_frame_scheduler1->TimerTaskRunner()->PostDelayedTask(
-        BLINK_FROM_HERE,
-        base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), 1);
+    web_frame_scheduler1->TimerTaskRunner()
+        ->ToSingleThreadTaskRunner()
+        ->PostDelayedTask(
+            BLINK_FROM_HERE,
+            base::Bind(&ExpensiveTestTask, clock_.get(), &run_times),
+            TimeDelta::FromMilliseconds(1));
   }
 
   mock_task_runner_->RunUntilIdle();
 
   // WebSocket is closed, budget-based throttling now applies.
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(84),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(109),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(134)));
 }
 
 }  // namespace scheduler
 }  // namespace blink