clang-format runtime/vm

runtime/vm/become.cc

 // 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.
 
 #include "vm/become.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/dart_api_state.h"
@@ skipping 44 matching lines @@
   uword addr = reinterpret_cast<uword>(object) - kHeapObjectTag;
   ForwardingCorpse* forwarder = reinterpret_cast<ForwardingCorpse*>(addr);
   return forwarder->target();
 }
 
 
 static void ForwardObjectTo(RawObject* before_obj, RawObject* after_obj) {
   const intptr_t size_before = before_obj->Size();
 
   uword corpse_addr = reinterpret_cast<uword>(before_obj) - kHeapObjectTag;
-  ForwardingCorpse* forwarder = ForwardingCorpse::AsForwarder(corpse_addr,
-                                                              size_before);
+  ForwardingCorpse* forwarder =
+      ForwardingCorpse::AsForwarder(corpse_addr, size_before);
   forwarder->set_target(after_obj);
   if (!IsForwardingObject(before_obj)) {
     FATAL("become: ForwardObjectTo failure.");
   }
   // Still need to be able to iterate over the forwarding corpse.
   const intptr_t size_after = before_obj->Size();
   if (size_before != size_after) {
     FATAL("become: Before and after sizes do not match.");
   }
 }
 
 
 class ForwardPointersVisitor : public ObjectPointerVisitor {
  public:
   explicit ForwardPointersVisitor(Isolate* isolate)
-      : ObjectPointerVisitor(isolate), visiting_object_(NULL), count_(0) { }
+      : ObjectPointerVisitor(isolate), visiting_object_(NULL), count_(0) {}
 
   virtual void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** p = first; p <= last; p++) {
       RawObject* old_target = *p;
       if (IsForwardingObject(old_target)) {
         RawObject* new_target = GetForwardedObject(old_target);
         if (visiting_object_ == NULL) {
           *p = new_target;
         } else {
           visiting_object_->StorePointer(p, new_target);
@@ skipping 11 matching lines @@
   RawObject* visiting_object_;
   intptr_t count_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardPointersVisitor);
 };
 
 
 class ForwardHeapPointersVisitor : public ObjectVisitor {
  public:
   explicit ForwardHeapPointersVisitor(ForwardPointersVisitor* pointer_visitor)
-      : pointer_visitor_(pointer_visitor) { }
+      : pointer_visitor_(pointer_visitor) {}
 
   virtual void VisitObject(RawObject* obj) {
     pointer_visitor_->VisitingObject(obj);
     obj->VisitPointers(pointer_visitor_);
   }
 
  private:
   ForwardPointersVisitor* pointer_visitor_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardHeapPointersVisitor);
 };
 
 
 class ForwardHeapPointersHandleVisitor : public HandleVisitor {
  public:
   ForwardHeapPointersHandleVisitor()
-      : HandleVisitor(Thread::Current()), count_(0) { }
+      : HandleVisitor(Thread::Current()), count_(0) {}
 
   virtual void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     if (IsForwardingObject(handle->raw())) {
       *handle->raw_addr() = GetForwardedObject(handle->raw());
       count_++;
     }
   }
 
@@ skipping 24 matching lines @@
       heap_->WriteProtectCode(true);
     }
   }
 
  private:
   Heap* heap_;
 };
 #else
 class WritableCodeLiteralsScope : public ValueObject {
  public:
-  explicit WritableCodeLiteralsScope(Heap* heap) { }
-  ~WritableCodeLiteralsScope() { }
+  explicit WritableCodeLiteralsScope(Heap* heap) {}
+  ~WritableCodeLiteralsScope() {}
 };
 #endif
 
 
 void Become::MakeDummyObject(const Instance& instance) {
   // Make the forward pointer point to itself.
   // This is needed to distinguish it from a real forward object.
   ForwardObjectTo(instance.raw(), instance.raw());
 }
 
@@ skipping 96 matching lines @@
     //   Heap pointers (may require updating the remembered set)
     {
       WritableCodeLiteralsScope writable_code(heap);
       ForwardHeapPointersVisitor object_visitor(&pointer_visitor);
       heap->VisitObjects(&object_visitor);
       pointer_visitor.VisitingObject(NULL);
     }
 
 #if !defined(PRODUCT)
     tds.SetNumArguments(2);
-    tds.FormatArgument(0, "Remapped objects", "%" Pd,  before.Length());
+    tds.FormatArgument(0, "Remapped objects", "%" Pd, before.Length());
     tds.FormatArgument(1, "Remapped references", "%" Pd,
                        pointer_visitor.count() + handle_visitor.count());
 #endif
   }
 
 #if defined(DEBUG)
   for (intptr_t i = 0; i < before.Length(); i++) {
     ASSERT(before.At(i) == after.At(i));
   }
 #endif
 }
 
 }  // namespace dart