clang-format runtime/vm

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 14 matching lines @@
 
 namespace dart {
 
 class FinalizablePersistentHandle;
 typedef MallocGrowableArray<FinalizablePersistentHandle*> FinalizationQueue;
 
 
 class BackgroundFinalizer : public ThreadPool::Task {
  public:
   BackgroundFinalizer(Isolate* isolate, FinalizationQueue* queue);
-  virtual ~BackgroundFinalizer() { }
+  virtual ~BackgroundFinalizer() {}
 
   void Run();
 
  private:
   Isolate* isolate_;
   FinalizationQueue* queue_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BackgroundFinalizer);
 };
 
@@ skipping 35 matching lines @@
       OS::PrintErr("*** Deleting Api zone 0x%" Px "(0x%" Px ")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
   }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  Checks for integer overflow when performing the
   // size computation.
   template <class ElementType>
-  ElementType* Alloc(intptr_t len) { return zone_.Alloc<ElementType>(len); }
+  ElementType* Alloc(intptr_t len) {
+    return zone_.Alloc<ElementType>(len);
+  }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  The new array is initialized from the memory of
   // 'old_array' up to 'old_len'.
   template <class ElementType>
   ElementType* Realloc(ElementType* old_array,
                        intptr_t old_len,
                        intptr_t new_len) {
     return zone_.Realloc<ElementType>(old_array, old_len, new_len);
   }
@@ skipping 24 matching lines @@
   void Reset(Thread* thread) {
     if ((thread != NULL) && (thread->zone() == &zone_)) {
       thread->set_zone(zone_.previous_);
     }
     zone_.DeleteAll();
   }
 
  private:
   Zone zone_;
 
-  template<typename T> friend class ApiGrowableArray;
+  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);
-  }
+  Dart_Handle apiHandle() { return reinterpret_cast<Dart_Handle>(this); }
 
  private:
-  LocalHandle() { }
-  ~LocalHandle() { }
+  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);
@@ skipping 13 matching lines @@
     return reinterpret_cast<Dart_PersistentHandle>(this);
   }
 
   static intptr_t raw_offset() { return OFFSET_OF(PersistentHandle, raw_); }
 
   static PersistentHandle* Cast(Dart_PersistentHandle handle);
 
  private:
   friend class PersistentHandles;
 
-  PersistentHandle() { }
-  ~PersistentHandle() { }
+  PersistentHandle() {}
+  ~PersistentHandle() {}
 
   // Overload the raw_ field as a next pointer when adding freed
   // handles to the free list.
-  PersistentHandle* Next() {
-    return reinterpret_cast<PersistentHandle*>(raw_);
-  }
+  PersistentHandle* Next() { return reinterpret_cast<PersistentHandle*>(raw_); }
   void SetNext(PersistentHandle* free_list) {
     raw_ = reinterpret_cast<RawObject*>(free_list);
     ASSERT(!raw_->IsHeapObject());
   }
-  void FreeHandle(PersistentHandle* free_list) {
-    SetNext(free_list);
-  }
+  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 {
@@ skipping 70 matching lines @@
     kExternalSizeBitsSize = (kBitsPerWord - 2),
   };
 
   // This part of external_data_ is the number of externally allocated bytes.
   class ExternalSizeInWordsBits : public BitField<uword,
                                                   intptr_t,
                                                   kExternalSizeBits,
                                                   kExternalSizeBitsSize> {};
   // This bit of external_data_ is true if the referent was created in new
   // space and UpdateRelocated has not yet detected any promotion.
-  class ExternalNewSpaceBit :
-      public BitField<uword, bool, kExternalNewSpaceBit, 1> {};
-  class QueuedForFinalizationBit :
-      public BitField<uword, bool, kQueuedForFinalizationBit, 1> {};
+  class ExternalNewSpaceBit
+      : public BitField<uword, bool, kExternalNewSpaceBit, 1> {};
+  class QueuedForFinalizationBit
+      : public BitField<uword, bool, kQueuedForFinalizationBit, 1> {};
 
   friend class FinalizablePersistentHandles;
 
   FinalizablePersistentHandle()
-      : raw_(NULL),
-        peer_(NULL),
-        external_data_(0),
-        callback_(NULL) { }
-  ~FinalizablePersistentHandle() { }
+      : raw_(NULL), peer_(NULL), external_data_(0), callback_(NULL) {}
+  ~FinalizablePersistentHandle() {}
 
   static void Finalize(Isolate* isolate, FinalizablePersistentHandle* handle);
 
   // Overload the raw_ field as a next pointer when adding freed
   // handles to the free list.
   FinalizablePersistentHandle* Next() {
     return reinterpret_cast<FinalizablePersistentHandle*>(raw_);
   }
   void SetNext(FinalizablePersistentHandle* free_list) {
     raw_ = reinterpret_cast<RawObject*>(free_list);
@@ skipping 22 matching lines @@
 
   void set_peer(void* peer) { peer_ = peer; }
 
   void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
     callback_ = callback;
   }
 
   void set_external_size(intptr_t size) {
     intptr_t size_in_words = Utils::RoundUp(size, kObjectAlignment) / kWordSize;
     ASSERT(ExternalSizeInWordsBits::is_valid(size_in_words));
-    external_data_ = ExternalSizeInWordsBits::update(size_in_words,
-                                                     external_data_);
+    external_data_ =
+        ExternalSizeInWordsBits::update(size_in_words, external_data_);
   }
 
   bool is_queued_for_finalization() const {
     return QueuedForFinalizationBit::decode(external_data_);
   }
   void set_is_queued_for_finalization(bool value) {
     external_data_ = QueuedForFinalizationBit::update(value, external_data_);
   }
 
   bool IsSetNewSpaceBit() const {
     return ExternalNewSpaceBit::decode(external_data_);
   }
 
   void SetExternalNewSpaceBit() {
     external_data_ = ExternalNewSpaceBit::update(true, external_data_);
   }
 
   void ClearExternalNewSpaceBit() {
     external_data_ = ExternalNewSpaceBit::update(false, external_data_);
   }
 
   // Returns the space to charge for the external size.
   Heap::Space SpaceForExternal() const {
     // Non-heap and VM-heap objects count as old space here.
-    return (raw_->IsHeapObject() && raw_->IsNewObject()) ?
-           Heap::kNew : Heap::kOld;
+    return (raw_->IsHeapObject() && raw_->IsNewObject()) ? Heap::kNew
+                                                         : Heap::kOld;
   }
 
   friend class BackgroundFinalizer;
 
   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>() {
+  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());
+                   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,
+    Handles<kLocalHandleSizeInWords, kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::VisitObjectPointers(visitor);
   }
 
   // Reset the local handles block for reuse.
   void Reset() {
-    Handles<kLocalHandleSizeInWords,
-            kLocalHandlesPerChunk,
+    Handles<kLocalHandleSizeInWords, kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::Reset();
   }
 
   // Allocates a handle in the current handle scope. This handle is valid only
   // in the current handle scope and is destroyed when the current handle
   // scope ends.
   LocalHandle* AllocateHandle() {
     return reinterpret_cast<LocalHandle*>(AllocateScopedHandle());
   }
 
   // Validate if passed in handle is a Local Handle.
   bool IsValidHandle(Dart_Handle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
-  int CountHandles() const {
-    return CountScopedHandles();
-  }
+  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() : Handles<kPersistentHandleSizeInWords,
-                                kPersistentHandlesPerChunk,
-                                kOffsetOfRawPtrInPersistentHandle>(),
+  PersistentHandles()
+      : Handles<kPersistentHandleSizeInWords,
+                kPersistentHandlesPerChunk,
+                kOffsetOfRawPtrInPersistentHandle>(),
         free_list_(NULL) {
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
   ~PersistentHandles() {
     free_list_ = NULL;
     if (FLAG_trace_handles) {
       OS::PrintErr("***   Handle Counts for 0x(%" Px "):Scoped = %d\n",
-                   reinterpret_cast<intptr_t>(this),
-                   CountHandles());
+                   reinterpret_cast<intptr_t>(this), CountHandles());
       OS::PrintErr("*** Deleting Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
 
   // Accessors.
   PersistentHandle* free_list() const { return free_list_; }
   void set_free_list(PersistentHandle* value) { free_list_ = value; }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
-    Handles<kPersistentHandleSizeInWords,
-            kPersistentHandlesPerChunk,
+    Handles<kPersistentHandleSizeInWords, kPersistentHandlesPerChunk,
             kOffsetOfRawPtrInPersistentHandle>::VisitObjectPointers(visitor);
   }
 
   // Visit all the handles.
   void Visit(HandleVisitor* visitor) {
-    Handles<kPersistentHandleSizeInWords,
-            kPersistentHandlesPerChunk,
+    Handles<kPersistentHandleSizeInWords, kPersistentHandlesPerChunk,
             kOffsetOfRawPtrInPersistentHandle>::Visit(visitor);
   }
 
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   PersistentHandle* AllocateHandle() {
     PersistentHandle* handle;
     if (free_list_ != NULL) {
       handle = free_list_;
       free_list_ = handle->Next();
     } else {
       handle = reinterpret_cast<PersistentHandle*>(AllocateScopedHandle());
     }
     handle->set_raw(Object::null());
     return handle;
   }
 
   void FreeHandle(PersistentHandle* handle) {
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_PersistentHandle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
-  int CountHandles() const {
-    return CountScopedHandles();
-  }
+  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;
+    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), mutex_(new Mutex()) { }
+        free_list_(NULL),
+        mutex_(new Mutex()) {}
   ~FinalizablePersistentHandles() {
     free_list_ = NULL;
     delete mutex_;
     mutex_ = 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);
+            kOffsetOfRawPtrInFinalizablePersistentHandle>::Visit(visitor);
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
-            kOffsetOfRawPtrInFinalizablePersistentHandle>::VisitObjectPointers(
-                visitor);
+            kOffsetOfRawPtrInFinalizablePersistentHandle>::
+        VisitObjectPointers(visitor);
   }
 
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   FinalizablePersistentHandle* AllocateHandle() {
     FinalizablePersistentHandle* handle;
     {
       MutexLocker ml(mutex_);
       if (free_list_ != NULL) {
         handle = free_list_;
         free_list_ = handle->Next();
         handle->set_raw(Object::null());
         return handle;
       }
     }
 
-    handle = reinterpret_cast<FinalizablePersistentHandle*>(
-          AllocateScopedHandle());
+    handle =
+        reinterpret_cast<FinalizablePersistentHandle*>(AllocateScopedHandle());
     handle->Clear();
     return handle;
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
     MutexLocker ml(mutex_);
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_WeakPersistentHandle object) const {
     MutexLocker ml(mutex_);
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
-  int CountHandles() const {
-    return CountScopedHandles();
-  }
+  int CountHandles() const { return CountScopedHandles(); }
 
  private:
   FinalizablePersistentHandle* free_list_;
   Mutex* mutex_;
   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;
-  }
+  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) {
     previous_ = previous;
     stack_marker_ = stack_marker;
     zone_.Reinit(thread);
   }
 
   // Reset the ApiLocalScope so that it can be reused again.
   void Reset(Thread* thread) {
@@ skipping 19 matching lines @@
   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));
+                             reinterpret_cast<uword>(this));
   }
 
   ~ApiNativeScope() {
     ASSERT(Current() == this);
     OSThread::SetThreadLocal(Api::api_native_key_, 0);
   }
 
   static inline ApiNativeScope* Current() {
     return reinterpret_cast<ApiNativeScope*>(
         OSThread::GetThreadLocal(Api::api_native_key_));
   }
 
   Zone* zone() {
     Zone* result = zone_.GetZone();
     ASSERT(result->handles()->CountScopedHandles() == 0);
     ASSERT(result->handles()->CountZoneHandles() == 0);
     return result;
   }
 
  private:
   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>
+template <typename T>
 class ApiGrowableArray : public BaseGrowableArray<T, ValueObject> {
  public:
   explicit ApiGrowableArray(int initial_capacity)
-      : BaseGrowableArray<T, ValueObject>(
-          initial_capacity,
-          ApiNativeScope::Current()->zone()) {}
+      : BaseGrowableArray<T, ValueObject>(initial_capacity,
+                                          ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
-      : BaseGrowableArray<T, ValueObject>(
-          ApiNativeScope::Current()->zone()) {}
+      : BaseGrowableArray<T, ValueObject>(ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray(intptr_t initial_capacity, Zone* zone)
       : BaseGrowableArray<T, ValueObject>(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),
-               false_(NULL),
-               acquired_error_(NULL) {}
+  ApiState()
+      : persistent_handles_(),
+        weak_persistent_handles_(),
+        null_(NULL),
+        true_(NULL),
+        false_(NULL),
+        acquired_error_(NULL) {}
   ~ApiState() {
     if (null_ != NULL) {
       persistent_handles().FreeHandle(null_);
       null_ = NULL;
     }
     if (true_ != NULL) {
       persistent_handles().FreeHandle(true_);
       true_ = NULL;
     }
     if (false_ != NULL) {
@@ skipping 84 matching lines @@
   ref->set_callback(callback);
   ref->set_is_queued_for_finalization(false);
   // 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_