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

third_party/WebKit/Source/platform/scheduler/child/worker_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/child/worker_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 222 matching lines @@
 }
 
 TEST_F(WorkerSchedulerImplTest, TestIdleTaskWhenIsNotQuiescent) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
   Init();
 
   timeline.push_back("Post default task");
   // Post a delayed task timed to occur mid way during the long idle period.
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())));
+      FROM_HERE,
+      base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
+                 base::Unretained(clock_.get())));
   RunUntilIdle();
 
   timeline.push_back("Post idle task");
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {"CanEnterLongIdlePeriod @ 5",
                                      "Post default task",
                                      "run RecordTimelineTask @ 5",
                                      "Post idle task",
                                      "IsNotQuiescent @ 5",
                                      "CanEnterLongIdlePeriod @ 305",
                                      "run TimelineIdleTestTask deadline 355"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 TEST_F(WorkerSchedulerImplTest, TestIdleDeadlineWithPendingDelayedTask) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
   Init();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur mid way during the long idle period.
   default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())),
+      FROM_HERE,
+      base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
+                 base::Unretained(clock_.get())),
       base::TimeDelta::FromMilliseconds(20));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks",
       "CanEnterLongIdlePeriod @ 5",
       "run TimelineIdleTestTask deadline 25",  // Note the short 20ms deadline.
       "run RecordTimelineTask @ 25"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 TEST_F(WorkerSchedulerImplTest,
        TestIdleDeadlineWithPendingDelayedTaskFarInTheFuture) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
   Init();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur well after the long idle period.
   default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())),
+      FROM_HERE,
+      base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
+                 base::Unretained(clock_.get())),
       base::TimeDelta::FromMilliseconds(500));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks",
       "CanEnterLongIdlePeriod @ 5",
       "run TimelineIdleTestTask deadline 55",  // Note the full 50ms deadline.
@@ skipping 44 matching lines @@
   RunUntilIdle();
 
   base::TimeTicks new_idle_period_deadline =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 
   // Post a task to post an idle task. Because the system is non-quiescent a
   // 300ms pause will occur before the next long idle period is initiated and
   // the idle task run.
   default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&PostIdleTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get()),
-                            base::Unretained(idle_task_runner_.get())),
+      FROM_HERE,
+      base::Bind(&PostIdleTask, base::Unretained(&timeline),
+                 base::Unretained(clock_.get()),
+                 base::Unretained(idle_task_runner_.get())),
       base::TimeDelta::FromMilliseconds(30));
 
   timeline.push_back("PostFirstIdleTask");
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
   RunUntilIdle();
   new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting();
 
   // Running a normal task will mark the system as non-quiescent.
   timeline.push_back("Post RecordTimelineTask");
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())));
+      FROM_HERE,
+      base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
+                 base::Unretained(clock_.get())));
   RunUntilIdle();
 
   std::string expected_timeline[] = {"RunUntilIdle begin @ 55",
                                      "RunUntilIdle end @ 55",
                                      "PostFirstIdleTask",
                                      "RunUntilIdle begin @ 55",
                                      "CanEnterLongIdlePeriod @ 55",
                                      "run TimelineIdleTestTask deadline 85",
                                      "run PostIdleTask @ 85",
                                      "IsNotQuiescent @ 85",
                                      "CanEnterLongIdlePeriod @ 385",
                                      "run TimelineIdleTestTask deadline 435",
                                      "RunUntilIdle end @ 385",
                                      "Post RecordTimelineTask",
                                      "RunUntilIdle begin @ 385",
                                      "run RecordTimelineTask @ 385",
                                      "RunUntilIdle end @ 385"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 }  // namespace scheduler
 }  // namespace blink