clang-format runtime/vm

runtime/vm/lockers.h

 // 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.
 
 #ifndef RUNTIME_VM_LOCKERS_H_
 #define RUNTIME_VM_LOCKERS_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
@@ skipping 152 matching lines @@
       Thread::Current()->DecrementNoSafepointScopeDepth();
     }
 #endif
   }
 
   Monitor::WaitResult Wait(int64_t millis = Monitor::kNoTimeout) {
     return monitor_->Wait(millis);
   }
 
   Monitor::WaitResult WaitWithSafepointCheck(
-      Thread* thread, int64_t millis = Monitor::kNoTimeout);
+      Thread* thread,
+      int64_t millis = Monitor::kNoTimeout);
 
   Monitor::WaitResult WaitMicros(int64_t micros = Monitor::kNoTimeout) {
     return monitor_->WaitMicros(micros);
   }
 
-  void Notify() {
-    monitor_->Notify();
-  }
+  void Notify() { monitor_->Notify(); }
 
-  void NotifyAll() {
-    monitor_->NotifyAll();
-  }
+  void NotifyAll() { monitor_->NotifyAll(); }
 
  private:
   Monitor* const monitor_;
   bool no_safepoint_scope_;
 
   DISALLOW_COPY_AND_ASSIGN(MonitorLocker);
 };
 
 /*
  * Safepoint mutex locker :
  * This locker abstraction should be used when the enclosing code could
  * potentially trigger a safepoint.
  * This locker ensures that other threads that try to acquire the same lock
  * will be marked as being at a safepoint if they get blocked trying to
  * acquire the lock.
  * NOTE: please do not use the passed in mutex object independent of the locker
  * class, For example the code below will not work correctly:
  *    {
  *      SafepointMutexLocker ml(m);
  *      ....
  *      m->Exit();
  *      ....
  *      m->Enter();
  *      ...
  *    }
  */
 class SafepointMutexLocker : public ValueObject {
  public:
   explicit SafepointMutexLocker(Mutex* mutex);
-  virtual ~SafepointMutexLocker() {
-    mutex_->Unlock();
-  }
+  virtual ~SafepointMutexLocker() { mutex_->Unlock(); }
 
  private:
   Mutex* const mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(SafepointMutexLocker);
 };
 
 /*
  * Safepoint monitor locker :
  * This locker abstraction should be used when the enclosing code could
  * potentially trigger a safepoint.
  * This locker ensures that other threads that try to acquire the same lock
  * will be marked as being at a safepoint if they get blocked trying to
  * acquire the lock.
  * NOTE: please do not use the passed in monitor object independent of the
  * locker class, For example the code below will not work correctly:
  *    {
  *      SafepointMonitorLocker ml(m);
  *      ....
  *      m->Exit();
  *      ....
  *      m->Enter();
  *      ...
  *    }
  */
 class SafepointMonitorLocker : public ValueObject {
  public:
   explicit SafepointMonitorLocker(Monitor* monitor);
-  virtual ~SafepointMonitorLocker() {
-    monitor_->Exit();
-  }
+  virtual ~SafepointMonitorLocker() { monitor_->Exit(); }
 
   Monitor::WaitResult Wait(int64_t millis = Monitor::kNoTimeout);
 
  private:
   Monitor* const monitor_;
 
   DISALLOW_COPY_AND_ASSIGN(SafepointMonitorLocker);
 };
 
 }  // namespace dart
 
 
 #endif  // RUNTIME_VM_LOCKERS_H_