VM: Re-format to use at most one newline between functions

runtime/vm/safepoint.h

 // Copyright (c) 2016, 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_SAFEPOINT_H_
 #define RUNTIME_VM_SAFEPOINT_H_
 
 #include "vm/globals.h"
 #include "vm/lockers.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 // A stack based scope that can be used to perform an operation after getting
 // all threads to a safepoint. At the end of the operation all the threads are
 // resumed.
 class SafepointOperationScope : public StackResource {
  public:
   explicit SafepointOperationScope(Thread* T);
   ~SafepointOperationScope();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafepointOperationScope);
 };
 
-
 // Implements handling of safepoint operations for all threads in an Isolate.
 class SafepointHandler {
  public:
   explicit SafepointHandler(Isolate* I);
   ~SafepointHandler();
 
   void EnterSafepointUsingLock(Thread* T);
   void ExitSafepointUsingLock(Thread* T);
 
   void BlockForSafepoint(Thread* T);
@@ skipping 50 matching lines @@
   int32_t safepoint_operation_count_;
 
   // If a safepoint operation is currently in progress, this field contains
   // the thread that initiated the safepoint operation, otherwise it is NULL.
   Thread* owner_;
 
   friend class Isolate;
   friend class SafepointOperationScope;
 };
 
-
 /*
  * Set of StackResource classes to track thread execution state transitions:
  *
  * kThreadInGenerated transitioning to
  *   ==> kThreadInVM:
  *       - set_execution_state(kThreadInVM).
  *       - block if safepoint is requested.
  *   ==> kThreadInNative:
  *       - set_execution_state(kThreadInNative).
  *       - EnterSafepoint().
@@ skipping 37 matching lines @@
   SafepointHandler* handler() const {
     ASSERT(thread()->isolate() != NULL);
     ASSERT(thread()->isolate()->safepoint_handler() != NULL);
     return thread()->isolate()->safepoint_handler();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionSafepointState);
 };
 
-
 // TransitionGeneratedToVM is used to transition the safepoint state of a
 // thread from "running generated code" to "running vm code" and ensures
 // that the state is reverted back to "running generated code" when
 // exiting the scope/frame.
 class TransitionGeneratedToVM : public TransitionSafepointState {
  public:
   explicit TransitionGeneratedToVM(Thread* T) : TransitionSafepointState(T) {
     ASSERT(T == Thread::Current());
     ASSERT(T->execution_state() == Thread::kThreadInGenerated);
     T->set_execution_state(Thread::kThreadInVM);
     // Fast check to see if a safepoint is requested or not.
     // We do the more expensive operation of blocking the thread
     // only if a safepoint is requested.
     if (T->IsSafepointRequested()) {
       handler()->BlockForSafepoint(T);
     }
   }
 
   ~TransitionGeneratedToVM() {
     ASSERT(thread()->execution_state() == Thread::kThreadInVM);
     thread()->set_execution_state(Thread::kThreadInGenerated);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionGeneratedToVM);
 };
 
-
 // TransitionGeneratedToNative is used to transition the safepoint state of a
 // thread from "running generated code" to "running native code" and ensures
 // that the state is reverted back to "running generated code" when
 // exiting the scope/frame.
 class TransitionGeneratedToNative : public TransitionSafepointState {
  public:
   explicit TransitionGeneratedToNative(Thread* T)
       : TransitionSafepointState(T) {
     // Native code is considered to be at a safepoint and so we mark it
     // accordingly.
     ASSERT(T->execution_state() == Thread::kThreadInGenerated);
     T->set_execution_state(Thread::kThreadInNative);
     T->EnterSafepoint();
   }
 
   ~TransitionGeneratedToNative() {
     // We are returning to generated code and so we are not at a safepoint
     // anymore.
     ASSERT(thread()->execution_state() == Thread::kThreadInNative);
     thread()->ExitSafepoint();
     thread()->set_execution_state(Thread::kThreadInGenerated);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionGeneratedToNative);
 };
 
-
 // TransitionVMToBlocked is used to transition the safepoint state of a
 // thread from "running vm code" to "blocked on a monitor" and ensures
 // that the state is reverted back to "running vm code" when
 // exiting the scope/frame.
 class TransitionVMToBlocked : public TransitionSafepointState {
  public:
   explicit TransitionVMToBlocked(Thread* T) : TransitionSafepointState(T) {
     // A thread blocked on a monitor is considered to be at a safepoint.
     ASSERT(T->execution_state() == Thread::kThreadInVM);
     T->set_execution_state(Thread::kThreadInBlockedState);
     T->EnterSafepoint();
   }
 
   ~TransitionVMToBlocked() {
     // We are returning to vm code and so we are not at a safepoint anymore.
     ASSERT(thread()->execution_state() == Thread::kThreadInBlockedState);
     thread()->ExitSafepoint();
     thread()->set_execution_state(Thread::kThreadInVM);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionVMToBlocked);
 };
 
-
 // TransitionVMToNative is used to transition the safepoint state of a
 // thread from "running vm code" to "running native code" and ensures
 // that the state is reverted back to "running vm code" when
 // exiting the scope/frame.
 class TransitionVMToNative : public TransitionSafepointState {
  public:
   explicit TransitionVMToNative(Thread* T) : TransitionSafepointState(T) {
     // A thread running native code is considered to be at a safepoint.
     ASSERT(T->execution_state() == Thread::kThreadInVM);
     T->set_execution_state(Thread::kThreadInNative);
     T->EnterSafepoint();
   }
 
   ~TransitionVMToNative() {
     // We are returning to vm code and so we are not at a safepoint anymore.
     ASSERT(thread()->execution_state() == Thread::kThreadInNative);
     thread()->ExitSafepoint();
     thread()->set_execution_state(Thread::kThreadInVM);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionVMToNative);
 };
 
-
 // TransitionVMToGenerated is used to transition the safepoint state of a
 // thread from "running vm code" to "running generated code" and ensures
 // that the state is reverted back to "running vm code" when
 // exiting the scope/frame.
 class TransitionVMToGenerated : public TransitionSafepointState {
  public:
   explicit TransitionVMToGenerated(Thread* T) : TransitionSafepointState(T) {
     ASSERT(T == Thread::Current());
     ASSERT(T->execution_state() == Thread::kThreadInVM);
     T->set_execution_state(Thread::kThreadInGenerated);
   }
 
   ~TransitionVMToGenerated() {
     ASSERT(thread()->execution_state() == Thread::kThreadInGenerated);
     thread()->set_execution_state(Thread::kThreadInVM);
     // Fast check to see if a safepoint is requested or not.
     // We do the more expensive operation of blocking the thread
     // only if a safepoint is requested.
     if (thread()->IsSafepointRequested()) {
       handler()->BlockForSafepoint(thread());
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionVMToGenerated);
 };
 
-
 // TransitionNativeToVM is used to transition the safepoint state of a
 // thread from "running native code" to "running vm code" and ensures
 // that the state is reverted back to "running native code" when
 // exiting the scope/frame.
 class TransitionNativeToVM : public TransitionSafepointState {
  public:
   explicit TransitionNativeToVM(Thread* T) : TransitionSafepointState(T) {
     // We are about to execute vm code and so we are not at a safepoint anymore.
     ASSERT(T->execution_state() == Thread::kThreadInNative);
     T->ExitSafepoint();
     T->set_execution_state(Thread::kThreadInVM);
   }
 
   ~TransitionNativeToVM() {
     // We are returning to native code and so we are at a safepoint.
     ASSERT(thread()->execution_state() == Thread::kThreadInVM);
     thread()->set_execution_state(Thread::kThreadInNative);
     thread()->EnterSafepoint();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransitionNativeToVM);
 };
 
-
 // TransitionToGenerated is used to transition the safepoint state of a
 // thread from "running vm code" or "running native code" to
 // "running generated code" and ensures that the state is reverted back
 // to "running vm code" or "running native code" when exiting the
 // scope/frame.
 class TransitionToGenerated : public TransitionSafepointState {
  public:
   explicit TransitionToGenerated(Thread* T)
       : TransitionSafepointState(T), execution_state_(T->execution_state()) {
     ASSERT(T == Thread::Current());
@@ skipping 14 matching lines @@
       ASSERT(execution_state_ == Thread::kThreadInVM);
       thread()->set_execution_state(Thread::kThreadInVM);
     }
   }
 
  private:
   uint32_t execution_state_;
   DISALLOW_COPY_AND_ASSIGN(TransitionToGenerated);
 };
 
-
 // TransitionToVM is used to transition the safepoint state of a
 // thread from "running native code" to "running vm code"
 // and ensures that the state is reverted back to "running native code"
 // when exiting the scope/frame.
 // This transition helper is mainly used in the error path of the
 // Dart API implementations where we sometimes do not have an explicit
 // transition set up.
 class TransitionToVM : public TransitionSafepointState {
  public:
   explicit TransitionToVM(Thread* T)
@@ skipping 17 matching lines @@
   }
 
  private:
   uint32_t execution_state_;
   DISALLOW_COPY_AND_ASSIGN(TransitionToVM);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SAFEPOINT_H_