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

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_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/task_queue_throttler.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 540 matching lines @@
 
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
   // Post an expensive task. Pool is now throttled.
   timer_queue_->PostDelayedTask(
       FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()),
       base::TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(1000)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000)));
   run_times.clear();
 
   LazyNow lazy_now(clock_.get());
   pool->DisableThrottling(&lazy_now);
   EXPECT_FALSE(pool->IsThrottlingEnabled());
 
   // Pool should not be throttled now.
   timer_queue_->PostDelayedTask(
       FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()),
       base::TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(2000)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000)));
   run_times.clear();
 
   lazy_now = LazyNow(clock_.get());
   pool->EnableThrottling(&lazy_now);
   EXPECT_TRUE(pool->IsThrottlingEnabled());
 
   // Because time pool was disabled, time budget level did not replenish
   // and queue is throttled.
   timer_queue_->PostDelayedTask(
       FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()),
       base::TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(4000)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4000)));
   run_times.clear();
 
   task_queue_throttler_->DecreaseThrottleRefCount(timer_queue_.get());
 
   pool->RemoveQueue(clock_->NowTicks(), timer_queue_.get());
   pool->Close();
 }
 
 TEST_F(TaskQueueThrottlerTest, ImmediateTasksTimeBudgetThrottling) {
   std::vector<base::TimeTicks> run_times;
@@ skipping 176 matching lines @@
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(300));
 
   // Disable throttling - task should run immediately.
   task_queue_throttler_->DisableThrottling();
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(500));
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(300)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300)));
   run_times.clear();
 
   // Schedule a task at 900ms. It should proceed as normal.
   timer_queue_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(400));
 
   // Schedule a task at 1200ms. It should proceed as normal.
   // PumpThrottledTasks was scheduled at 1000ms, so it needs to be checked
   // that it was cancelled and it does not interfere with tasks posted before
@@ skipping 18 matching lines @@
                                 base::TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(1400));
 
   // Throttling is enabled and new task should be aligned.
   task_queue_throttler_->EnableThrottling();
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(2000)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000)));
 }
 
 namespace {
 
 void RecordThrottling(std::vector<base::TimeDelta>* reported_throttling_times,
                       base::TimeDelta throttling_duration) {
   reported_throttling_times->push_back(throttling_duration);
 }
 
 }  // namespace
@@ skipping 99 matching lines @@
 
   lazy_now = LazyNow(clock_.get());
   pool->EnableThrottling(&lazy_now);
 
   timer_queue_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(200));
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(300)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300)));
 }
 
 TEST_F(TaskQueueThrottlerTest, AddQueueToBudgetPoolWhenThrottlingDisabled) {
   // This test checks that a task queue is added to time budget pool
   // when throttling is disabled, is does not throttle queue.
   std::vector<base::TimeTicks> run_times;
 
   task_queue_throttler_->DisableThrottling();
 
   TaskQueueThrottler::TimeBudgetPool* pool =
       task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
                                                   base::nullopt);
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +
                                   base::TimeDelta::FromMilliseconds(100));
 
   timer_queue_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(200));
 
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(300)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300)));
 }
 
 TEST_F(TaskQueueThrottlerTest, DisabledQueueThenEnabledQueue) {
   std::vector<base::TimeTicks> run_times;
 
   scoped_refptr<TaskQueue> second_queue =
       scheduler_->NewTimerTaskRunner(TaskQueue::QueueType::TEST);
 
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
   task_queue_throttler_->IncreaseThrottleRefCount(second_queue.get());
 
   timer_queue_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(100));
   second_queue->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(200));
 
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       timer_queue_->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(250));
 
   mock_task_runner_->RunUntilIdle();
 
-  EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() +
-                                     base::TimeDelta::FromMilliseconds(1000)));
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000)));
 
   voter->SetQueueEnabled(true);
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000),
                   base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000)));
 }
 
 }  // namespace scheduler
 }  // namespace blink