DO NOT SUBMIT results of new clang-format

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 1379 matching lines @@
   test_task_runner_->RunUntilIdle();
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40));
   ASSERT_THAT(run_order, ElementsAre(1, 3));
 }
 
 namespace {
 void UnregisterQueue(scoped_refptr<internal::TaskQueueImpl> queue) {
   queue->UnregisterTaskQueue();
 }
-}
+}  // namespace
 
 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_InTasks) {
   Initialize(3u);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[1]));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[2]));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
@@ skipping 702 matching lines @@
 
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
 namespace {
 void CurrentlyExecutingTaskQueueTestTask(
     TaskQueueManager* task_queue_manager,
     std::vector<TaskQueue*>* task_sources) {
   task_sources->push_back(task_queue_manager->currently_executing_task_queue());
 }
-}
+}  // namespace
 
 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));
@@ skipping 14 matching lines @@
   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
   task_sources->push_back(task_queue_manager->currently_executing_task_queue());
 
   for (std::pair<base::Closure, TaskQueue*>& pair : *tasks) {
     pair.second->PostTask(FROM_HERE, pair.first);
   }
 
   base::RunLoop().RunUntilIdle();
   task_sources->push_back(task_queue_manager->currently_executing_task_queue());
 }
-}
+}  // namespace
 
 TEST_F(TaskQueueManagerTest, CurrentlyExecutingTaskQueue_NestedLoop) {
   InitializeWithRealMessageLoop(3u);
 
   TaskQueue* queue0 = runners_[0].get();
   TaskQueue* queue1 = runners_[1].get();
   TaskQueue* queue2 = runners_[2].get();
 
   std::vector<TaskQueue*> task_sources;
   std::vector<std::pair<base::Closure, TaskQueue*>>
@@ skipping 95 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> wake_up_times;
 
   RunUntilIdle(base::Bind(
       [](std::set<base::TimeTicks>* wake_up_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> wake_up_times;
 
   RunUntilIdle(base::Bind(
       [](std::set<base::TimeTicks>* wake_up_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 wake-up 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 419 matching lines @@
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
   manager_->UnregisterTimeDomain(domain.get());
 }
 
 }  // namespace scheduler
 }  // namespace blink