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

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_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/base/task_queue_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 254 matching lines @@
   runners_.push_back(
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)));
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   for (int i = 0; i <= 6; ++i) {
     tasks_to_post_from_nested_loop.push_back(
         std::make_pair(base::Bind(&NopTask), true));
   }
 
   runners_[0]->PostTask(
-      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
-                            base::RetainedRef(runners_[0]),
-                            base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE,
+      base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                 base::RetainedRef(runners_[0]),
+                 base::Unretained(&tasks_to_post_from_nested_loop)));
 
   base::RunLoop().RunUntilIdle();
   // We need to call Now twice, to measure the start and end of the outermost
   // task. We shouldn't call it for any of the nested tasks.
   EXPECT_EQ(2, test_count_uses_time_source->now_calls_count());
 }
 
 void NullTask() {}
 
 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) {
@@ skipping 62 matching lines @@
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 
   runners_[0]->PostTask(
-      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
-                            base::RetainedRef(runners_[0]),
-                            base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE,
+      base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                 base::RetainedRef(runners_[0]),
+                 base::Unretained(&tasks_to_post_from_nested_loop)));
 
   base::RunLoop().RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_ImmediateTask) {
   Initialize(1u);
 
   std::vector<EnqueueOrder> run_order;
@@ skipping 481 matching lines @@
       FROM_HERE, base::Bind(&PostTaskToRunner, runners_[0], &run_order));
   thread.Stop();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 void RePostingTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
                        int* run_count) {
   (*run_count)++;
-  runner->PostTask(FROM_HERE, Bind(&RePostingTestTask,
-                                   base::Unretained(runner.get()), run_count));
+  runner->PostTask(
+      FROM_HERE,
+      Bind(&RePostingTestTask, base::Unretained(runner.get()), run_count));
 }
 
 TEST_F(TaskQueueManagerTest, DoWorkCantPostItselfMultipleTimes) {
   Initialize(1u);
 
   int run_count = 0;
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&RePostingTestTask, runners_[0], &run_count));
 
   test_task_runner_->RunPendingTasks();
   // NOTE without the executing_task_ check in MaybeScheduleDoWork there
   // will be two tasks here.
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
   runners_[0]->PostTask(
-      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
-                            base::RetainedRef(runners_[0]),
-                            base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE,
+      base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                 base::RetainedRef(runners_[0]),
+                 base::Unretained(&tasks_to_post_from_nested_loop)));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, WorkBatching) {
   Initialize(1u);
 
@@ skipping 186 matching lines @@
 
   base::TimeTicks run_time;
   EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time));
   EXPECT_EQ(now_src_->NowTicks() + delay2, run_time);
 }
 
 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) {
   Initialize(1u);
 
   runners_[0]->PostTask(
-      FROM_HERE, base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager,
-                            base::Unretained(this)));
+      FROM_HERE,
+      base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager,
+                 base::Unretained(this)));
 
   // This should not crash, assuming DoWork detects the TaskQueueManager has
   // been deleted.
   test_task_runner_->RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, GetAndClearSystemIsQuiescentBit) {
   Initialize(3u);
 
   scoped_refptr<internal::TaskQueueImpl> queue0 =
@@ skipping 76 matching lines @@
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   for (int i = 10; i < 19; i++) {
     runners_[0]->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ExpensiveTestTask, i, now_src_.get(), &run_order), delay);
   }
 
   test_task_runner_->RunForPeriod(delay);
 
   for (int i = 0; i < 9; i++) {
-    runners_[0]->PostTask(FROM_HERE, base::Bind(&ExpensiveTestTask, i,
-                                                now_src_.get(), &run_order));
+    runners_[0]->PostTask(
+        FROM_HERE,
+        base::Bind(&ExpensiveTestTask, i, now_src_.get(), &run_order));
   }
 
   test_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   test_task_runner_->RunUntilIdle();
 
   // Delayed tasks are not allowed to starve out immediate work which is why
   // some of the immediate tasks run out of order.
   int expected_run_order[] = {10, 11, 12, 13, 0, 14, 15, 16, 1,
                               17, 18, 2,  3,  4, 5,  6,  7,  8};
   EXPECT_THAT(run_order, ElementsAreArray(expected_run_order));
@@ skipping 65 matching lines @@
 }
 
 TEST_F(TaskQueueManagerTest, QuitWhileNested) {
   // This test makes sure we don't continue running a work batch after a nested
   // run loop has been exited in the middle of the batch.
   InitializeWithRealMessageLoop(1u);
   manager_->SetWorkBatchSize(2);
 
   bool was_nested = true;
   base::RunLoop run_loop;
-  runners_[0]->PostTask(FROM_HERE, base::Bind(&PostAndQuitFromNestedRunloop,
-                                              base::Unretained(&run_loop),
-                                              base::RetainedRef(runners_[0]),
-                                              base::Unretained(&was_nested)));
+  runners_[0]->PostTask(
+      FROM_HERE,
+      base::Bind(&PostAndQuitFromNestedRunloop, base::Unretained(&run_loop),
+                 base::RetainedRef(runners_[0]),
+                 base::Unretained(&was_nested)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(was_nested);
 }
 
 class SequenceNumberCapturingTaskObserver
     : public base::MessageLoop::TaskObserver {
  public:
   // MessageLoop::TaskObserver overrides.
   void WillProcessTask(const base::PendingTask& pending_task) override {}
@@ skipping 218 matching lines @@
                      true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&internal::TaskQueueImpl::UnregisterTaskQueue,
                                 base::Unretained(task_queue.get())),
                      true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&HasOneRefTask, base::Unretained(&log),
                                 base::Unretained(task_queue.get())),
                      true));
   runners_[0]->PostTask(
-      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
-                            base::RetainedRef(runners_[0]),
-                            base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE,
+      base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                 base::RetainedRef(runners_[0]),
+                 base::Unretained(&tasks_to_post_from_nested_loop)));
   base::RunLoop().RunUntilIdle();
 
   // Add a final call to HasOneRefTask.  This gives the manager a chance to
   // release its reference, and checks that it has.
   runners_[0]->PostTask(FROM_HERE,
                         base::Bind(&HasOneRefTask, base::Unretained(&log),
                                    base::Unretained(task_queue.get())));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(log, ElementsAre(false, false, true));
@@ skipping 499 matching lines @@
 }
 }
 
 TEST_F(TaskQueueManagerTest, CurrentlyExecutingTaskQueue_TaskRunning) {
   Initialize(2u);
 
   internal::TaskQueueImpl* queue0 = runners_[0].get();
   internal::TaskQueueImpl* queue1 = runners_[1].get();
 
   std::vector<TaskQueue*> task_sources;
-  queue0->PostTask(FROM_HERE, base::Bind(&CurrentlyExecutingTaskQueueTestTask,
-                                         manager_.get(), &task_sources));
-  queue1->PostTask(FROM_HERE, base::Bind(&CurrentlyExecutingTaskQueueTestTask,
-                                         manager_.get(), &task_sources));
+  queue0->PostTask(FROM_HERE,
+                   base::Bind(&CurrentlyExecutingTaskQueueTestTask,
+                              manager_.get(), &task_sources));
+  queue1->PostTask(FROM_HERE,
+                   base::Bind(&CurrentlyExecutingTaskQueueTestTask,
+                              manager_.get(), &task_sources));
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(task_sources, ElementsAre(queue0, queue1));
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
 namespace {
 void RunloopCurrentlyExecutingTaskQueueTestTask(
     base::MessageLoop* message_loop,
     TaskQueueManager* task_queue_manager,
@@ skipping 23 matching lines @@
       tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&CurrentlyExecutingTaskQueueTestTask,
                                 manager_.get(), &task_sources),
                      queue1));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&CurrentlyExecutingTaskQueueTestTask,
                                 manager_.get(), &task_sources),
                      queue2));
 
-  queue0->PostTask(
-      FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask,
-                            message_loop_.get(), manager_.get(), &task_sources,
-                            &tasks_to_post_from_nested_loop));
+  queue0->PostTask(FROM_HERE,
+                   base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask,
+                              message_loop_.get(), manager_.get(),
+                              &task_sources, &tasks_to_post_from_nested_loop));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0));
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
 void OnTraceDataCollected(base::Closure quit_closure,
                           base::trace_event::TraceResultBuffer* buffer,
                           const scoped_refptr<base::RefCountedString>& json,
                           bool has_more_events) {
@@ skipping 84 matching lines @@
   CancelableTask task1(now_src_.get());
   CancelableTask task2(now_src_.get());
   CancelableTask task3(now_src_.get());
   CancelableTask task4(now_src_.get());
   base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
   base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
   base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
   std::vector<base::TimeTicks> run_times;
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task1.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task1.weak_factory_.GetWeakPtr(), &run_times),
       delay1);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task2.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task2.weak_factory_.GetWeakPtr(), &run_times),
       delay2);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task3.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task3.weak_factory_.GetWeakPtr(), &run_times),
       delay3);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task4.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task4.weak_factory_.GetWeakPtr(), &run_times),
       delay4);
 
   task2.weak_factory_.InvalidateWeakPtrs();
   task3.weak_factory_.InvalidateWeakPtrs();
 
   std::set<base::TimeTicks> wakeup_times;
 
   RunUntilIdle(base::Bind(
       [](std::set<base::TimeTicks>* wakeup_times,
          base::SimpleTestTickClock* clock) {
@@ skipping 14 matching lines @@
   CancelableTask task1(now_src_.get());
   CancelableTask task2(now_src_.get());
   CancelableTask task3(now_src_.get());
   CancelableTask task4(now_src_.get());
   base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
   base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
   base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
   std::vector<base::TimeTicks> run_times;
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task4.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task4.weak_factory_.GetWeakPtr(), &run_times),
       delay4);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task3.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task3.weak_factory_.GetWeakPtr(), &run_times),
       delay3);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task2.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task2.weak_factory_.GetWeakPtr(), &run_times),
       delay2);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task1.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task1.weak_factory_.GetWeakPtr(), &run_times),
       delay1);
 
   task2.weak_factory_.InvalidateWeakPtrs();
   task3.weak_factory_.InvalidateWeakPtrs();
 
   std::set<base::TimeTicks> wakeup_times;
 
   RunUntilIdle(base::Bind(
       [](std::set<base::TimeTicks>* wakeup_times,
          base::SimpleTestTickClock* clock) {
@@ skipping 14 matching lines @@
   CancelableTask task1(now_src_.get());
   CancelableTask task2(now_src_.get());
   CancelableTask task3(now_src_.get());
   CancelableTask task4(now_src_.get());
   base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
   base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
   base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
   std::vector<base::TimeTicks> run_times;
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task1.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task1.weak_factory_.GetWeakPtr(), &run_times),
       delay1);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task2.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task2.weak_factory_.GetWeakPtr(), &run_times),
       delay2);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task3.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task3.weak_factory_.GetWeakPtr(), &run_times),
       delay3);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task4.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task4.weak_factory_.GetWeakPtr(), &run_times),
       delay4);
 
   // Post a non-canceled task with |delay3|. So we should still get a wakeup at
   // |delay3| even though we cancel |task3|.
   runners_[0]->PostDelayedTask(FROM_HERE,
                                base::Bind(&CancelableTask::RecordTimeTask,
                                           base::Unretained(&task3), &run_times),
                                delay3);
 
   task2.weak_factory_.InvalidateWeakPtrs();
@@ skipping 100 matching lines @@
   CancelableTask task1(now_src_.get());
   CancelableTask task2(now_src_.get());
   CancelableTask task3(now_src_.get());
   CancelableTask task4(now_src_.get());
   base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
   base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
   base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
   std::vector<base::TimeTicks> run_times;
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task1.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task1.weak_factory_.GetWeakPtr(), &run_times),
       delay1);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task2.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task2.weak_factory_.GetWeakPtr(), &run_times),
       delay2);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task3.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task3.weak_factory_.GetWeakPtr(), &run_times),
       delay3);
   runners_[0]->PostDelayedTask(
-      FROM_HERE, base::Bind(&CancelableTask::RecordTimeTask,
-                            task4.weak_factory_.GetWeakPtr(), &run_times),
+      FROM_HERE,
+      base::Bind(&CancelableTask::RecordTimeTask,
+                 task4.weak_factory_.GetWeakPtr(), &run_times),
       delay4);
 
   EXPECT_EQ(4u, runners_[0]->GetNumberOfPendingTasks());
   task2.weak_factory_.InvalidateWeakPtrs();
   task3.weak_factory_.InvalidateWeakPtrs();
   EXPECT_EQ(4u, runners_[0]->GetNumberOfPendingTasks());
 
   manager_->SweepCanceledDelayedTasks();
   EXPECT_EQ(2u, runners_[0]->GetNumberOfPendingTasks());
 
@@ skipping 393 matching lines @@
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
 
   // Neither should fences.
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
   EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
 }
 
 }  // namespace scheduler
 }  // namespace blink