clang-format runtime/vm

runtime/vm/thread_pool_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/os.h"
 #include "vm/lockers.h"
 #include "vm/thread_pool.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 DECLARE_FLAG(int, worker_timeout_millis);
 
 
 UNIT_TEST_CASE(ThreadPool_Create) {
   ThreadPool thread_pool;
 }
 
 
 class TestTask : public ThreadPool::Task {
  public:
-  TestTask(Monitor* sync, bool* done)
-      : sync_(sync), done_(done) {
-  }
+  TestTask(Monitor* sync, bool* done) : sync_(sync), done_(done) {}
 
   // Before running the task, *done_ should be true. This lets the caller
   // ASSERT things knowing that the thread is still around. To unblock the
   // thread, the caller should take the lock, set *done_ to false, and Notify()
   // the monitor.
   virtual void Run() {
     {
       MonitorLocker ml(sync_);
       while (*done_) {
         ml.Wait();
@@ skipping 52 matching lines @@
   }
 }
 
 
 class SleepTask : public ThreadPool::Task {
  public:
   SleepTask(Monitor* sync, int* started_count, int* slept_count, int millis)
       : sync_(sync),
         started_count_(started_count),
         slept_count_(slept_count),
-        millis_(millis) {
-  }
+        millis_(millis) {}
 
   virtual void Run() {
     {
       MonitorLocker ml(sync_);
       *started_count_ = *started_count_ + 1;
       ml.Notify();
     }
     // Sleep so we can be sure the ThreadPool destructor blocks until we're
     // done.
     OS::Sleep(millis_);
@@ skipping 84 matching lines @@
     waited += 1;
   }
   EXPECT_EQ(1U, thread_pool.workers_stopped());
   FLAG_worker_timeout_millis = saved_timeout;
 }
 
 
 class SpawnTask : public ThreadPool::Task {
  public:
   SpawnTask(ThreadPool* pool, Monitor* sync, int todo, int total, int* done)
-      : pool_(pool), sync_(sync), todo_(todo), total_(total), done_(done) {
-  }
+      : pool_(pool), sync_(sync), todo_(todo), total_(total), done_(done) {}
 
   virtual void Run() {
     todo_--;  // Subtract one for current task.
     int child_todo = todo_ / 2;
 
     // Spawn 0-2 children.
     if (todo_ > 0) {
-      pool_->Run(new SpawnTask(
-          pool_, sync_, todo_ - child_todo, total_, done_));
+      pool_->Run(
+          new SpawnTask(pool_, sync_, todo_ - child_todo, total_, done_));
     }
     if (todo_ > 1) {
       pool_->Run(new SpawnTask(pool_, sync_, child_todo, total_, done_));
     }
 
     {
       MonitorLocker ml(sync_);
       (*done_)++;
       if (*done_ >= total_) {
         ml.Notify();
@@ skipping 20 matching lines @@
   {
     MonitorLocker ml(&sync);
     while (done < kTotalTasks) {
       ml.Wait();
     }
   }
   EXPECT_EQ(kTotalTasks, done);
 }
 
 }  // namespace dart