clang-format runtime/vm

runtime/vm/object_graph.cc

 // Copyright (c) 2014, 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/object_graph.h"
 
 #include "vm/dart.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/reusable_handles.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // The state of a pre-order, depth-first traversal of an object graph.
 // When a node is visited, *all* its children are pushed to the stack at once.
 // We insert a sentinel between the node and its children on the stack, to
 // remember that the node has been visited. The node is kept on the stack while
 // its children are processed, to give the visitor a complete chain of parents.
 //
 // TODO(koda): Potential optimizations:
 // - Use tag bits for compact Node and sentinel representations.
 class ObjectGraph::Stack : public ObjectPointerVisitor {
  public:
   explicit Stack(Isolate* isolate)
-      : ObjectPointerVisitor(isolate), data_(kInitialCapacity) { }
+      : ObjectPointerVisitor(isolate), data_(kInitialCapacity) {}
 
   // Marks and pushes. Used to initialize this stack with roots.
   virtual void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; ++current) {
       if ((*current)->IsHeapObject() && !(*current)->IsMarked()) {
         (*current)->SetMarkBit();
         Node node;
         node.ptr = current;
         node.obj = *current;
         data_.Add(node);
@@ skipping 92 matching lines @@
     // Some internal VM objects visit pointers not contained within the parent.
     // For instance, RawCode::VisitCodePointers visits pointers in instructions.
     ASSERT(!parent.obj->IsDartInstance());
     return -1;
   }
 }
 
 
 class Unmarker : public ObjectVisitor {
  public:
-  Unmarker() { }
+  Unmarker() {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsMarked()) {
       obj->ClearMarkBit();
     }
   }
 
   static void UnmarkAll(Isolate* isolate) {
     Unmarker unmarker;
     isolate->heap()->IterateObjects(&unmarker);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Unmarker);
 };
 
 
-ObjectGraph::ObjectGraph(Thread* thread)
-    : StackResource(thread) {
+ObjectGraph::ObjectGraph(Thread* thread) : StackResource(thread) {
   // The VM isolate has all its objects pre-marked, so iterating over it
   // would be a no-op.
   ASSERT(thread->isolate() != Dart::vm_isolate());
   thread->isolate()->heap()->WriteProtectCode(false);
 }
 
 
 ObjectGraph::~ObjectGraph() {
   isolate()->heap()->WriteProtectCode(true);
 }
@@ skipping 15 matching lines @@
   RawObject* root_raw = root.raw();
   stack.VisitPointer(&root_raw);
   stack.TraverseGraph(visitor);
   Unmarker::UnmarkAll(isolate());
 }
 
 
 class InstanceAccumulator : public ObjectVisitor {
  public:
   InstanceAccumulator(ObjectGraph::Stack* stack, intptr_t class_id)
-      : stack_(stack), class_id_(class_id) { }
+      : stack_(stack), class_id_(class_id) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->GetClassId() == class_id_) {
       RawObject* rawobj = obj;
       stack_->VisitPointer(&rawobj);
     }
   }
 
  private:
   ObjectGraph::Stack* stack_;
@@ skipping 11 matching lines @@
   InstanceAccumulator accumulator(&stack, class_id);
   isolate()->heap()->IterateObjects(&accumulator);
 
   stack.TraverseGraph(visitor);
   Unmarker::UnmarkAll(isolate());
 }
 
 
 class SizeVisitor : public ObjectGraph::Visitor {
  public:
-  SizeVisitor() : size_(0) { }
+  SizeVisitor() : size_(0) {}
   intptr_t size() const { return size_; }
   virtual bool ShouldSkip(RawObject* obj) const { return false; }
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     RawObject* obj = it->Get();
     if (ShouldSkip(obj)) {
       return kBacktrack;
     }
     size_ += obj->Size();
     return kProceed;
   }
+
  private:
   intptr_t size_;
 };
 
 
 class SizeExcludingObjectVisitor : public SizeVisitor {
  public:
-  explicit SizeExcludingObjectVisitor(const Object& skip) : skip_(skip) { }
+  explicit SizeExcludingObjectVisitor(const Object& skip) : skip_(skip) {}
   virtual bool ShouldSkip(RawObject* obj) const { return obj == skip_.raw(); }
+
  private:
   const Object& skip_;
 };
 
 
 class SizeExcludingClassVisitor : public SizeVisitor {
  public:
-  explicit SizeExcludingClassVisitor(intptr_t skip) : skip_(skip) { }
+  explicit SizeExcludingClassVisitor(intptr_t skip) : skip_(skip) {}
   virtual bool ShouldSkip(RawObject* obj) const {
     return obj->GetClassId() == skip_;
   }
+
  private:
   const intptr_t skip_;
 };
 
 
 intptr_t ObjectGraph::SizeRetainedByInstance(const Object& obj) {
   SizeVisitor total;
   IterateObjects(&total);
   intptr_t size_total = total.size();
   SizeExcludingObjectVisitor excluding_obj(obj);
@@ skipping 36 matching lines @@
     ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0);
   }
 
   intptr_t length() const { return length_; }
 
   bool ShouldSkip(RawObject* obj) {
     // A retaining path through ICData is never the only retaining path,
     // and it is less informative than its alternatives.
     intptr_t cid = obj->GetClassId();
     switch (cid) {
-    case kICDataCid:
-      return true;
-    default:
-      return false;
+      case kICDataCid:
+        return true;
+      default:
+        return false;
     }
   }
 
   bool ShouldStop(RawObject* obj) {
     // A static field is considered a root from a language point of view.
     if (obj->IsField()) {
       const Field& field = Field::Handle(static_cast<RawField*>(obj));
       return field.is_static();
     }
     return false;
   }
 
-  void StartList() {
-    was_last_array_ = false;
-  }
+  void StartList() { was_last_array_ = false; }
 
   intptr_t HideNDescendant(RawObject* obj) {
     // A GrowableObjectArray overwrites its internal storage.
     // Keeping both of them in the list is redundant.
     if (was_last_array_ && obj->IsGrowableObjectArray()) {
       was_last_array_ = false;
       return 1;
     }
     // A LinkedHasMap overwrites its internal storage.
     // Keeping both of them in the list is redundant.
@@ skipping 57 matching lines @@
 
 
 class InboundReferencesVisitor : public ObjectVisitor,
                                  public ObjectPointerVisitor {
  public:
   // We cannot use a GrowableObjectArray, since we must not trigger GC.
   InboundReferencesVisitor(Isolate* isolate,
                            RawObject* target,
                            const Array& references,
                            Object* scratch)
-    : ObjectPointerVisitor(isolate), source_(NULL),
-      target_(target), references_(references), scratch_(scratch), length_(0) {
+      : ObjectPointerVisitor(isolate),
+        source_(NULL),
+        target_(target),
+        references_(references),
+        scratch_(scratch),
+        length_(0) {
     ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0);
   }
 
   intptr_t length() const { return length_; }
 
   virtual void VisitObject(RawObject* raw_obj) {
     source_ = raw_obj;
     raw_obj->VisitPointers(this);
   }
 
@@ skipping 76 matching lines @@
   }
 
   intptr_t count() const { return count_; }
 
  private:
   WriteStream* stream_;
   intptr_t count_;
 };
 
 
-static void WriteHeader(RawObject* raw, intptr_t size, intptr_t cid,
-                 WriteStream* stream) {
+static void WriteHeader(RawObject* raw,
+                        intptr_t size,
+                        intptr_t cid,
+                        WriteStream* stream) {
   WritePtr(raw, stream);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   stream->WriteUnsigned(size);
   stream->WriteUnsigned(cid);
 }
 
 
 class WriteGraphVisitor : public ObjectGraph::Visitor {
  public:
   WriteGraphVisitor(Isolate* isolate, WriteStream* stream)
-    : stream_(stream), ptr_writer_(isolate, stream), count_(0) {}
+      : stream_(stream), ptr_writer_(isolate, stream), count_(0) {}
 
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     RawObject* raw_obj = it->Get();
     Thread* thread = Thread::Current();
     REUSABLE_OBJECT_HANDLESCOPE(thread);
     Object& obj = thread->ObjectHandle();
     obj = raw_obj;
     // Each object is a header + a zero-terminated list of its neighbors.
     WriteHeader(raw_obj, raw_obj->Size(), obj.GetClassId(), stream_);
     raw_obj->VisitPointers(&ptr_writer_);
@@ skipping 26 matching lines @@
   {
     WritePointerVisitor ptr_writer(isolate(), stream);
     isolate()->IterateObjectPointers(&ptr_writer, false);
   }
   stream->WriteUnsigned(0);
   IterateObjects(&visitor);
   return visitor.count() + 1;  // + root
 }
 
 }  // namespace dart