clang-format runtime/vm

runtime/vm/handles.h

 // Copyright (c) 2011, 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_HANDLES_H_
 #define RUNTIME_VM_HANDLES_H_
 
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/os.h"
@@ skipping 66 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(HandleVisitor);
 };
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 class Handles {
  public:
   Handles()
       : zone_blocks_(NULL),
         first_scoped_block_(NULL),
-        scoped_blocks_(&first_scoped_block_) {
-  }
-  ~Handles() {
-    DeleteAll();
-  }
+        scoped_blocks_(&first_scoped_block_) {}
+  ~Handles() { DeleteAll(); }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   // Visit all the scoped handles.
   void VisitScopedHandles(ObjectPointerVisitor* visitor);
 
   // Visit all blocks that have been added since the last time
   // this method was called.
   // Be careful with this, since multiple users of this method could
@@ skipping 39 matching lines @@
  private:
   // Base structure for managing blocks of handles.
   // Handles are allocated in Chunks (each chunk holds kHandlesPerChunk
   // handles). The chunk is uninitialized, subsequent requests for handles
   // is allocated from the chunk until we run out space in the chunk,
   // at this point another chunk is allocated. These chunks are chained
   // together.
   class HandlesBlock {
    public:
     explicit HandlesBlock(HandlesBlock* next)
-        : next_handle_slot_(0),
-          next_block_(next) { }
+        : next_handle_slot_(0), next_block_(next) {}
     ~HandlesBlock();
 
     // Reinitializes handle block for reuse.
     void ReInit();
 
     // Returns true if the handle block is full.
     bool IsFull() const {
       return next_handle_slot_ >= (kHandleSizeInWords * kHandlesPerChunk);
     }
 
@@ skipping 30 matching lines @@
     intptr_t next_handle_slot() const { return next_handle_slot_; }
     void set_next_handle_slot(intptr_t next_handle_slot) {
       next_handle_slot_ = next_handle_slot;
     }
     HandlesBlock* next_block() const { return next_block_; }
     void set_next_block(HandlesBlock* next) { next_block_ = next; }
 
    private:
     uword data_[kHandleSizeInWords * kHandlesPerChunk];  // Handles area.
     intptr_t next_handle_slot_;  // Next slot for allocation in current block.
-    HandlesBlock* next_block_;  // Link to next block of handles.
+    HandlesBlock* next_block_;   // Link to next block of handles.
 
     DISALLOW_COPY_AND_ASSIGN(HandlesBlock);
   };
 
   // Deletes all the allocated handle blocks.
   void DeleteAll();
   void DeleteHandleBlocks(HandlesBlock* blocks);
 
   // Sets up the next handle block (allocates a new one if needed).
   void SetupNextScopeBlock();
@@ skipping 10 matching lines @@
   void SetupNextZoneBlock();
 
 #if defined(DEBUG)
   // Verifies consistency of handle blocks after a scope is destroyed.
   void VerifyScopedHandleState();
 
   // Zaps the free scoped handles to an uninitialized value.
   void ZapFreeScopedHandles();
 #endif
 
-  HandlesBlock* zone_blocks_;  // List of zone handles.
+  HandlesBlock* zone_blocks_;        // List of zone handles.
   HandlesBlock first_scoped_block_;  // First block of scoped handles.
-  HandlesBlock* scoped_blocks_;  // List of scoped handles.
+  HandlesBlock* scoped_blocks_;      // List of scoped handles.
 
   friend class HandleScope;
   friend class Dart;
   friend class ObjectStore;
   friend class Thread;
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Handles);
 };
 
 
 static const int kVMHandleSizeInWords = 2;
 static const int kVMHandlesPerChunk = 64;
 static const int kOffsetOfRawPtr = kWordSize;
 class VMHandles : public Handles<kVMHandleSizeInWords,
                                  kVMHandlesPerChunk,
                                  kOffsetOfRawPtr> {
  public:
   static const int kOffsetOfRawPtrInHandle = kOffsetOfRawPtr;
 
-  VMHandles() : Handles<kVMHandleSizeInWords,
-                        kVMHandlesPerChunk,
-                        kOffsetOfRawPtr>() {
+  VMHandles()
+      : Handles<kVMHandleSizeInWords, kVMHandlesPerChunk, kOffsetOfRawPtr>() {
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new VM handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
   ~VMHandles();
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
@@ skipping 38 matching lines @@
   VMHandles::HandlesBlock* saved_handle_block_;  // Handle block at prev scope.
   uword saved_handle_slot_;  // Next available handle slot at previous scope.
 #if defined(DEBUG)
   HandleScope* link_;  // Link to previous scope.
 #endif
   DISALLOW_IMPLICIT_CONSTRUCTORS(HandleScope);
 };
 
 // Macro to start a new Handle scope.
 #define HANDLESCOPE(thread)                                                    \
-    dart::HandleScope vm_internal_handles_scope_(thread);
+  dart::HandleScope vm_internal_handles_scope_(thread);
 
 
 // The class NoHandleScope is used in critical regions of the virtual machine
 // code where raw dart object pointers are directly manipulated.
 // This class asserts that we do not add code that will allocate new handles
 // during this critical area.
 // It is used as follows:
 // {
 //   NOHANDLESCOPE(thread);
 //   ....
 //   .....
 //   critical code that manipulates dart objects directly.
 //   ....
 // }
 #if defined(DEBUG)
 class NoHandleScope : public StackResource {
  public:
   explicit NoHandleScope(Thread* thread);
   ~NoHandleScope();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoHandleScope);
 };
-#else  // defined(DEBUG)
+#else   // defined(DEBUG)
 class NoHandleScope : public ValueObject {
  public:
-  explicit NoHandleScope(Thread* thread) { }
-  NoHandleScope() { }
-  ~NoHandleScope() { }
+  explicit NoHandleScope(Thread* thread) {}
+  NoHandleScope() {}
+  ~NoHandleScope() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoHandleScope);
 };
 #endif  // defined(DEBUG)
 
 // Macro to start a no handles scope in the code.
 #define NOHANDLESCOPE(thread)                                                  \
-    dart::NoHandleScope no_vm_internal_handles_scope_(thread);
+  dart::NoHandleScope no_vm_internal_handles_scope_(thread);
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_HANDLES_H_