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

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define RUNTIME_VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 103 matching lines @@
   }
 
  private:
   Zone zone_;
 
   template <typename T>
   friend class ApiGrowableArray;
   DISALLOW_COPY_AND_ASSIGN(ApiZone);
 };
 
-
 // Implementation of local handles which are handed out from every
 // dart API call, these handles are valid only in the present scope
 // and are destroyed when a Dart_ExitScope() is called.
 class LocalHandle {
  public:
   // Accessors.
   RawObject* raw() const { return raw_; }
   void set_raw(RawObject* raw) { raw_ = raw; }
   static intptr_t raw_offset() { return OFFSET_OF(LocalHandle, raw_); }
 
   Dart_Handle apiHandle() { return reinterpret_cast<Dart_Handle>(this); }
 
  private:
   LocalHandle() {}
   ~LocalHandle() {}
 
   RawObject* raw_;
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(LocalHandle);
 };
 
-
 // A distinguished callback which indicates that a persistent handle
 // should not be deleted from the dart api.
 void ProtectedHandleCallback(void* peer);
 
-
 // Implementation of persistent handles which are handed out through the
 // dart API.
 class PersistentHandle {
  public:
   // Accessors.
   RawObject* raw() const { return raw_; }
   void set_raw(RawObject* ref) { raw_ = ref; }
   void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
   void set_raw(const Object& object) { raw_ = object.raw(); }
   RawObject** raw_addr() { return &raw_; }
@@ skipping 18 matching lines @@
     raw_ = reinterpret_cast<RawObject*>(free_list);
     ASSERT(!raw_->IsHeapObject());
   }
   void FreeHandle(PersistentHandle* free_list) { SetNext(free_list); }
 
   RawObject* raw_;
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(PersistentHandle);
 };
 
-
 // Implementation of persistent handles which are handed out through the
 // dart API.
 class FinalizablePersistentHandle {
  public:
   static FinalizablePersistentHandle* New(
       Isolate* isolate,
       const Object& object,
       void* peer,
       Dart_WeakPersistentHandleFinalizer callback,
       intptr_t external_size);
@@ skipping 130 matching lines @@
 
   RawObject* raw_;
   void* peer_;
   uword external_data_;
   Dart_WeakPersistentHandleFinalizer callback_;
 
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandle);
 };
 
-
 // Local handles repository structure.
 static const int kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize;
 static const int kLocalHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInLocalHandle = 0;
 class LocalHandles : Handles<kLocalHandleSizeInWords,
                              kLocalHandlesPerChunk,
                              kOffsetOfRawPtrInLocalHandle> {
  public:
   LocalHandles()
       : Handles<kLocalHandleSizeInWords,
                 kLocalHandlesPerChunk,
                 kOffsetOfRawPtrInLocalHandle>() {
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new Local handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
   ~LocalHandles() {
     if (FLAG_trace_handles) {
       OS::PrintErr("***   Handle Counts for 0x(%" Px "):Scoped = %d\n",
                    reinterpret_cast<intptr_t>(this), CountHandles());
       OS::PrintErr("*** Deleting Local handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
 
-
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kLocalHandleSizeInWords, kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::VisitObjectPointers(visitor);
   }
 
   // Reset the local handles block for reuse.
   void Reset() {
     Handles<kLocalHandleSizeInWords, kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::Reset();
@@ skipping 11 matching lines @@
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LocalHandles);
 };
 
-
 // Persistent handles repository structure.
 static const int kPersistentHandleSizeInWords =
     sizeof(PersistentHandle) / kWordSize;
 static const int kPersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInPersistentHandle = 0;
 class PersistentHandles : Handles<kPersistentHandleSizeInWords,
                                   kPersistentHandlesPerChunk,
                                   kOffsetOfRawPtrInPersistentHandle> {
  public:
   PersistentHandles()
@@ skipping 68 matching lines @@
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   PersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(PersistentHandles);
 };
 
-
 // Finalizable persistent handles repository structure.
 static const int kFinalizablePersistentHandleSizeInWords =
     sizeof(FinalizablePersistentHandle) / kWordSize;
 static const int kFinalizablePersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInFinalizablePersistentHandle = 0;
 class FinalizablePersistentHandles
     : Handles<kFinalizablePersistentHandleSizeInWords,
               kFinalizablePersistentHandlesPerChunk,
               kOffsetOfRawPtrInFinalizablePersistentHandle> {
  public:
   FinalizablePersistentHandles()
       : Handles<kFinalizablePersistentHandleSizeInWords,
                 kFinalizablePersistentHandlesPerChunk,
                 kOffsetOfRawPtrInFinalizablePersistentHandle>(),
         free_list_(NULL) {}
-  ~FinalizablePersistentHandles() {
-    free_list_ = NULL;
-  }
+  ~FinalizablePersistentHandles() { free_list_ = NULL; }
 
   // Accessors.
   FinalizablePersistentHandle* free_list() const { return free_list_; }
   void set_free_list(FinalizablePersistentHandle* value) { free_list_ = value; }
 
   // Visit all handles stored in the various handle blocks.
   void VisitHandles(HandleVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::Visit(visitor);
@@ skipping 46 matching lines @@
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   FinalizablePersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };
 
-
 // Structure used for the implementation of local scopes used in dart_api.
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker)
       : previous_(previous), stack_marker_(stack_marker) {}
   ~ApiLocalScope() { previous_ = NULL; }
 
   // Reinit the ApiLocalScope to new values.
   void Reinit(Thread* thread, ApiLocalScope* previous, uword stack_marker) {
@@ skipping 19 matching lines @@
 
  private:
   ApiLocalScope* previous_;
   uword stack_marker_;
   LocalHandles local_handles_;
   ApiZone zone_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiLocalScope);
 };
 
-
 class ApiNativeScope {
  public:
   ApiNativeScope() {
     // Currently no support for nesting native scopes.
     ASSERT(Current() == NULL);
     OSThread::SetThreadLocal(Api::api_native_key_,
                              reinterpret_cast<uword>(this));
     // We manually increment the memory usage counter since there is memory
     // initially allocated within the zone on creation.
     IncrementNativeScopeMemoryCapacity(zone_.GetZone()->CapacityInBytes());
@@ skipping 30 matching lines @@
     return result;
   }
 
  private:
   // The current total memory usage within ApiNativeScopes.
   static intptr_t current_memory_usage_;
 
   ApiZone zone_;
 };
 
-
 // Api growable arrays use a zone for allocation. The constructor
 // picks the zone from the current isolate if in an isolate
 // environment. When outside an isolate environment it picks the zone
 // from the current native scope.
 template <typename T>
 class ApiGrowableArray : public BaseGrowableArray<T, ValueObject, Zone> {
  public:
   explicit ApiGrowableArray(int initial_capacity)
       : BaseGrowableArray<T, ValueObject, Zone>(
             initial_capacity,
             ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject, Zone>(
             ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray(intptr_t initial_capacity, Zone* zone)
       : BaseGrowableArray<T, ValueObject, Zone>(initial_capacity, zone) {}
 };
 
-
 // Implementation of the API State used in dart api for maintaining
 // local scopes, persistent handles etc. These are setup on a per isolate
 // basis and destroyed when the isolate is shutdown.
 class ApiState {
  public:
   ApiState()
       : persistent_handles_(),
         weak_persistent_handles_(),
         null_(NULL),
         true_(NULL),
@@ skipping 90 matching lines @@
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
   PersistentHandle* acquired_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
 
-
 inline FinalizablePersistentHandle* FinalizablePersistentHandle::New(
     Isolate* isolate,
     const Object& object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback,
     intptr_t external_size) {
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   FinalizablePersistentHandle* ref =
       state->weak_persistent_handles().AllocateHandle();
   ref->set_raw(object);
   ref->set_peer(peer);
   ref->set_callback(callback);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DART_API_STATE_H_