DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 58 matching lines @@
   *deadline_out = deadline;
 }
 
 int max_idle_task_reposts = 2;
 
 void RepostingIdleTestTask(SingleThreadIdleTaskRunner* idle_task_runner,
                            int* run_count,
                            base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
-        FROM_HERE, base::Bind(&RepostingIdleTestTask,
-                              base::Unretained(idle_task_runner), run_count));
+        FROM_HERE,
+        base::Bind(&RepostingIdleTestTask, base::Unretained(idle_task_runner),
+                   run_count));
   }
   (*run_count)++;
 }
 
 void RepostingUpdateClockIdleTestTask(
     SingleThreadIdleTaskRunner* idle_task_runner,
     int* run_count,
     base::SimpleTestTickClock* clock,
     base::TimeDelta advance_time,
     std::vector<base::TimeTicks>* deadlines,
     base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
-        FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
-                              base::Unretained(idle_task_runner), run_count,
-                              clock, advance_time, deadlines));
+        FROM_HERE,
+        base::Bind(&RepostingUpdateClockIdleTestTask,
+                   base::Unretained(idle_task_runner), run_count, clock,
+                   advance_time, deadlines));
   }
   deadlines->push_back(deadline);
   (*run_count)++;
   clock->Advance(advance_time);
 }
 
 void WillBeginFrameIdleTask(RendererScheduler* scheduler,
                             uint64_t sequence_number,
                             base::SimpleTestTickClock* clock,
                             base::TimeTicks deadline) {
@@ skipping 586 matching lines @@
   PostTestTasks(&run_order, "D1 C1");
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::Contains("D1"));
   EXPECT_THAT(run_order, testing::Contains("C1"));
 }
 
 TEST_F(RendererSchedulerImplTest, TestRentrantTask) {
   int count = 0;
   std::vector<int> run_order;
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(AppendToVectorReentrantTask,
-                            base::RetainedRef(default_task_runner_), &run_order,
-                            &count, 5));
+      FROM_HERE,
+      base::Bind(AppendToVectorReentrantTask,
+                 base::RetainedRef(default_task_runner_), &run_order, &count,
+                 5));
   RunUntilIdle();
 
   EXPECT_THAT(run_order, testing::ElementsAre(0, 1, 2, 3, 4));
 }
 
 TEST_F(RendererSchedulerImplTest, TestPostIdleTask) {
   int run_count = 0;
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
   base::TimeTicks deadline_in_task;
@@ skipping 26 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&RepostingIdleTestTask,
-                            base::RetainedRef(idle_task_runner_), &run_count));
+      FROM_HERE,
+      base::Bind(&RepostingIdleTestTask, base::RetainedRef(idle_task_runner_),
+                 &run_count));
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   EnableIdleTasks();
   RunUntilIdle();
@@ skipping 126 matching lines @@
             CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_CompositorHandlesInput_LongGestureDuration) {
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   base::TimeTicks loop_end_time =
-      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(
-                               UserModel::kMedianGestureDurationMillis * 2);
+      clock_->NowTicks() +
+      base::TimeDelta::FromMilliseconds(
+          UserModel::kMedianGestureDurationMillis * 2);
 
   // The UseCase::COMPOSITOR_GESTURE usecase initially deprioritizes compositor
   // tasks (see TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler)
   // but if the gesture is long enough, compositor tasks get prioritized again.
   while (clock_->NowTicks() < loop_end_time) {
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::TouchMove),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     clock_->Advance(base::TimeDelta::FromMilliseconds(16));
     RunUntilIdle();
@@ skipping 719 matching lines @@
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("L1")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestIsHighPriorityWorkAnticipated) {
   bool is_anticipated_before = false;
   bool is_anticipated_after = false;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
-                            SimulateInputType::None, &is_anticipated_before,
-                            &is_anticipated_after));
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::None, &is_anticipated_before,
+                 &is_anticipated_after));
   RunUntilIdle();
   // In its default state, without input receipt, the scheduler should indicate
   // that no high-priority is anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
 
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
-                            SimulateInputType::TouchStart,
-                            &is_anticipated_before, &is_anticipated_after));
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::TouchStart, &is_anticipated_before,
+                 &is_anticipated_after));
   bool dummy;
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
-                            SimulateInputType::TouchEnd, &dummy, &dummy));
-  default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::TouchEnd, &dummy, &dummy));
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
                  SimulateInputType::GestureScrollBegin, &dummy, &dummy));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AnticipationTestTask, scheduler_.get(),
                  SimulateInputType::GestureScrollEnd, &dummy, &dummy));
 
   RunUntilIdle();
   // When input is received, the scheduler should indicate that high-priority
   // work is anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_TRUE(is_anticipated_after);
 
   clock_->Advance(priority_escalation_after_input_duration() * 2);
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
-                            SimulateInputType::None, &is_anticipated_before,
-                            &is_anticipated_after));
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::None, &is_anticipated_before,
+                 &is_anticipated_after));
   RunUntilIdle();
   // Without additional input, the scheduler should go into NONE
   // use case but with scrolling expected where high-priority work is still
   // anticipated.
   EXPECT_EQ(UseCase::NONE, CurrentUseCase());
   EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_TRUE(is_anticipated_before);
   EXPECT_TRUE(is_anticipated_after);
 
   clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
-                            SimulateInputType::None, &is_anticipated_before,
-                            &is_anticipated_after));
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::None, &is_anticipated_before,
+                 &is_anticipated_after));
   RunUntilIdle();
   // Eventually the scheduler should go into the default use case where
   // high-priority work is no longer anticipated.
   EXPECT_EQ(UseCase::NONE, CurrentUseCase());
   EXPECT_FALSE(TouchStartExpectedSoon());
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
 }
 
 TEST_F(RendererSchedulerImplTest, TestShouldYield) {
   bool should_yield_before = false;
   bool should_yield_after = false;
 
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            base::RetainedRef(default_task_runner_), false,
-                            &should_yield_before, &should_yield_after));
+      FROM_HERE,
+      base::Bind(&PostingYieldingTestTask, scheduler_.get(),
+                 base::RetainedRef(default_task_runner_), false,
+                 &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // Posting to default runner shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            base::RetainedRef(compositor_task_runner_), false,
-                            &should_yield_before, &should_yield_after));
+      FROM_HERE,
+      base::Bind(&PostingYieldingTestTask, scheduler_.get(),
+                 base::RetainedRef(compositor_task_runner_), false,
+                 &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // Posting while not mainthread scrolling shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            base::RetainedRef(compositor_task_runner_), true,
-                            &should_yield_before, &should_yield_after));
+      FROM_HERE,
+      base::Bind(&PostingYieldingTestTask, scheduler_.get(),
+                 base::RetainedRef(compositor_task_runner_), true,
+                 &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // We should be able to switch to compositor priority mid-task.
   EXPECT_FALSE(should_yield_before);
   EXPECT_TRUE(should_yield_after);
 }
 
 TEST_F(RendererSchedulerImplTest, TestShouldYield_TouchStart) {
   // Receiving a touchstart should immediately trigger yielding, even if
   // there's no immediately pending work in the compositor queue.
   EXPECT_FALSE(scheduler_->ShouldYieldForHighPriorityWork());
@@ skipping 313 matching lines @@
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &RendererSchedulerImplWithMessageLoopTest::PostFromNestedRunloop,
           base::Unretained(this),
           base::Unretained(&tasks_to_post_from_nested_loop)));
 
   EnableIdleTasks();
   RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
-  EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
-                                          std::string("4"), std::string("5"),
-                                          std::string("3")));
+  EXPECT_THAT(
+      order,
+      testing::ElementsAre(std::string("1"), std::string("2"), std::string("4"),
+                           std::string("5"), std::string("3")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriod) {
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + maximum_idle_period_duration();
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
@@ skipping 168 matching lines @@
       base::TimeTicks(), base::TimeDelta::FromMilliseconds(1000),
       cc::BeginFrameArgs::NORMAL));
   EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());
 }
 
 TEST_F(RendererSchedulerImplTest, TestRendererHiddenIdlePeriod) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&RepostingIdleTestTask,
-                            base::RetainedRef(idle_task_runner_), &run_count));
+      FROM_HERE,
+      base::Bind(&RepostingIdleTestTask, base::RetainedRef(idle_task_runner_),
+                 &run_count));
 
   // Renderer should start in visible state.
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // When we hide the renderer it should start a max deadline idle period, which
   // will run an idle task and then immediately start a new idle period, which
   // runs the second idle task.
   scheduler_->SetAllRenderWidgetsHidden(true);
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 
   // Advance time by amount of time by the maximum amount of time we execute
   // idle tasks when hidden (plus some slack) - idle period should have ended.
   max_idle_task_reposts = 3;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&RepostingIdleTestTask,
-                            base::RetainedRef(idle_task_runner_), &run_count));
+      FROM_HERE,
+      base::Bind(&RepostingIdleTestTask, base::RetainedRef(idle_task_runner_),
+                 &run_count));
   clock_->Advance(end_idle_when_hidden_delay() +
                   base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TimerQueueEnabledByDefault) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "T1 T2");
   RunUntilIdle();
@@ skipping 549 matching lines @@
     simulate_timer_task_ran_ = false;
 
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
 
     compositor_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RendererSchedulerImplTest::
-                                  SimulateMainThreadInputHandlingCompositorTask,
-                              base::Unretained(this),
-                              base::TimeDelta::FromMilliseconds(8)));
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::
+                       SimulateMainThreadInputHandlingCompositorTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(8)));
     timer_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
-                              base::Unretained(this),
-                              base::TimeDelta::FromMilliseconds(4)));
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(4)));
 
     RunUntilIdle();
     EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
     EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
               CurrentUseCase())
         << " i = " << i;
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
@@ skipping 17 matching lines @@
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidAnimateForInputOnCompositorThread();
 
     compositor_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask,
                    base::Unretained(this),
                    base::TimeDelta::FromMilliseconds(8)));
     timer_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
-                              base::Unretained(this),
-                              base::TimeDelta::FromMilliseconds(40)));
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(40)));
 
     RunUntilIdle();
     EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
     EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
               CurrentUseCase())
         << " i = " << i;
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
@@ skipping 13 matching lines @@
     simulate_timer_task_ran_ = false;
 
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
 
     compositor_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RendererSchedulerImplTest::
-                                  SimulateMainThreadInputHandlingCompositorTask,
-                              base::Unretained(this),
-                              base::TimeDelta::FromMilliseconds(8)));
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::
+                       SimulateMainThreadInputHandlingCompositorTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(8)));
     timer_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
-                              base::Unretained(this),
-                              base::TimeDelta::FromMilliseconds(10)));
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(10)));
 
     RunUntilIdle();
     EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
               CurrentUseCase())
         << " i = " << i;
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     if (i == 0) {
       EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
     } else {
       EXPECT_TRUE(TimerTasksSeemExpensive()) << " i = " << i;
@@ skipping 215 matching lines @@
   EXPECT_EQ(0u, web_view_scheduler.interventions().size());
 }
 
 namespace {
 void SlowCountingTask(size_t* count,
                       base::SimpleTestTickClock* clock,
                       int task_duration,
                       scoped_refptr<base::SingleThreadTaskRunner> timer_queue) {
   clock->Advance(base::TimeDelta::FromMilliseconds(task_duration));
   if (++(*count) < 500) {
-    timer_queue->PostTask(FROM_HERE, base::Bind(SlowCountingTask, count, clock,
-                                                task_duration, timer_queue));
+    timer_queue->PostTask(
+        FROM_HERE,
+        base::Bind(SlowCountingTask, count, clock, task_duration, timer_queue));
   }
 }
 }
 
 TEST_F(RendererSchedulerImplTest,
        SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_expensive) {
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   base::TimeTicks first_throttled_run_time =
       TaskQueueThrottler::AlignedThrottledRunTime(clock_->NowTicks());
 
   size_t count = 0;
   // With the compositor task taking 10ms, there is not enough time to run this
   // 7ms timer task in the 16ms frame.
   scheduler_->TimerTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(SlowCountingTask, &count, clock_.get(), 7,
-                            scheduler_->TimerTaskRunner()));
+      FROM_HERE,
+      base::Bind(SlowCountingTask, &count, clock_.get(), 7,
+                 scheduler_->TimerTaskRunner()));
 
   for (int i = 0; i < 1000; i++) {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
@@ skipping 41 matching lines @@
        SYNCHRONIZED_GESTURE_TimerTaskThrottling_TimersSuspended) {
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   base::TimeTicks first_throttled_run_time =
       TaskQueueThrottler::AlignedThrottledRunTime(clock_->NowTicks());
 
   size_t count = 0;
   // With the compositor task taking 10ms, there is not enough time to run this
   // 7ms timer task in the 16ms frame.
   scheduler_->TimerTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(SlowCountingTask, &count, clock_.get(), 7,
-                            scheduler_->TimerTaskRunner()));
+      FROM_HERE,
+      base::Bind(SlowCountingTask, &count, clock_.get(), 7,
+                 scheduler_->TimerTaskRunner()));
 
   bool suspended = false;
   for (int i = 0; i < 1000; i++) {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidHandleInputEventOnCompositorThread(
@@ skipping 37 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplTest,
        SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_not_expensive) {
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   size_t count = 0;
   // With the compositor task taking 10ms, there is enough time to run this 6ms
   // timer task in the 16ms frame.
   scheduler_->TimerTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(SlowCountingTask, &count, clock_.get(), 6,
-                            scheduler_->TimerTaskRunner()));
+      FROM_HERE,
+      base::Bind(SlowCountingTask, &count, clock_.get(), 6,
+                 scheduler_->TimerTaskRunner()));
 
   for (int i = 0; i < 1000; i++) {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
@@ skipping 287 matching lines @@
 TEST_F(RendererSchedulerImplTest, UnthrottledTaskRunner) {
   // Ensure neither suspension nor timer task throttling affects an unthrottled
   // task runner.
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
   scoped_refptr<TaskQueue> unthrottled_task_runner =
       scheduler_->NewUnthrottledTaskRunner(TaskQueue::QueueType::UNTHROTTLED);
 
   size_t timer_count = 0;
   size_t unthrottled_count = 0;
   scheduler_->TimerTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(SlowCountingTask, &timer_count, clock_.get(), 7,
-                            scheduler_->TimerTaskRunner()));
+      FROM_HERE,
+      base::Bind(SlowCountingTask, &timer_count, clock_.get(), 7,
+                 scheduler_->TimerTaskRunner()));
   unthrottled_task_runner->PostTask(
-      FROM_HERE, base::Bind(SlowCountingTask, &unthrottled_count, clock_.get(),
-                            7, unthrottled_task_runner));
+      FROM_HERE,
+      base::Bind(SlowCountingTask, &unthrottled_count, clock_.get(), 7,
+                 unthrottled_task_runner));
   scheduler_->SuspendTimerQueue();
 
   for (int i = 0; i < 1000; i++) {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
         base::TimeTicks(), base::TimeDelta::FromMilliseconds(16),
         cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidHandleInputEventOnCompositorThread(
@@ skipping 101 matching lines @@
   scheduler_->OnRendererBackgrounded();
 
   std::vector<base::TimeTicks> run_times;
 
   timer_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RecordingTimeTestTask, &run_times, clock_.get()));
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(1100));
 
-  EXPECT_THAT(run_times, testing::ElementsAre(base::TimeTicks() +
-                                              base::TimeDelta::FromSeconds(1)));
+  EXPECT_THAT(run_times,
+              testing::ElementsAre(base::TimeTicks() +
+                                   base::TimeDelta::FromSeconds(1)));
   run_times.clear();
 
   timer_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&RecordingTimeTestTask, &run_times, clock_.get()),
       base::TimeDelta::FromMilliseconds(200));
 
   scheduler_->OnRendererForegrounded();
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(1500));
@@ skipping 48 matching lines @@
   EXPECT_TRUE(
       scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold()));
   // Once we've dropped the lock, we realize the main thread is responsive.
   DropQueueingTimeEstimatorLock();
   EXPECT_FALSE(
       scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold()));
 }
 
 }  // namespace scheduler
 }  // namespace blink