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

third_party/WebKit/Source/platform/scheduler/child/idle_helper_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/idle_helper.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 75 matching lines @@
 
 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 RepeatingTask(base::SingleThreadTaskRunner* task_runner,
                    int num_repeats,
                    base::TimeDelta delay) {
   if (num_repeats > 1) {
     task_runner->PostDelayedTask(
-        FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner),
-                              num_repeats - 1, delay),
+        FROM_HERE,
+        base::Bind(&RepeatingTask, base::Unretained(task_runner),
+                   num_repeats - 1, delay),
         delay);
   }
 }
 
 void UpdateClockIdleTestTask(base::SimpleTestTickClock* clock,
                              int* run_count,
                              base::TimeTicks set_time,
                              base::TimeTicks deadline) {
   clock->Advance(set_time - clock->NowTicks());
   (*run_count)++;
@@ skipping 151 matching lines @@
   static base::TimeDelta minimum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         IdleHelper::kMinimumIdlePeriodDurationMillis);
   }
 
   base::TimeTicks CurrentIdleTaskDeadline() {
     return idle_helper_->CurrentIdleTaskDeadline();
   }
 
   void CheckIdlePeriodStateIs(const char* expected) {
-    EXPECT_STREQ(expected, IdleHelper::IdlePeriodStateToString(
-                               idle_helper_->SchedulerIdlePeriodState()));
+    EXPECT_STREQ(expected,
+                 IdleHelper::IdlePeriodStateToString(
+                     idle_helper_->SchedulerIdlePeriodState()));
   }
 
   const scoped_refptr<TaskQueue>& idle_queue() const {
     return idle_helper_->idle_queue_;
   }
 
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   std::unique_ptr<base::MessageLoop> message_loop_;
@@ skipping 224 matching lines @@
       FROM_HERE,
       base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop,
                  base::Unretained(this),
                  base::Unretained(&tasks_to_post_from_nested_loop)));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   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(IdleHelperTestWithIdlePeriodObserver, 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 410 matching lines @@
   // Run a repeating task so we're deemed to be busy for the next 400ms.
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RepeatingTask, base::Unretained(default_task_runner_.get()),
                  10, base::TimeDelta::FromMilliseconds(40)));
 
   int run_count = 0;
   // In this scenario EnableLongIdlePeriod deems us not to be quiescent 5x in
   // a row.
   base::TimeTicks expected_deadline =
-      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(
-                               5 * kQuiescenceDelayMs + kLongIdlePeriodMs);
+      clock_->NowTicks() +
+      base::TimeDelta::FromMilliseconds(5 * kQuiescenceDelayMs +
+                                        kLongIdlePeriodMs);
   base::TimeTicks deadline_in_task;
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
@@ skipping 139 matching lines @@
       expected_deadline);
   EXPECT_EQ(1u, idle_queue()->GetNumberOfPendingTasks());
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 }  // namespace scheduler
 }  // namespace blink