Avoid to list internal Arrays in _GetRetainingPath api

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"
@@ skipping 301 matching lines @@
     // and it is less informative than its alternatives.
     intptr_t cid = obj->GetClassId();
     switch (cid) {
     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() {
+    wasLastArray_ = false;

[Cutch, 2016/08/12 14:23:39]

C++ style guide says variables are lower_case_like_this:

was_last_array_;

[cbernaschina, 2016/08/12 17:28:24]

Done.

+  }
+
+  bool ShouldOverwrite(RawObject* obj) {

[Cutch, 2016/08/12 14:23:40]

ShouldReplace?

[cbernaschina, 2016/08/12 17:28:24]

Changed approach, and name

+    // A GrowableObjectArray overwrites its internal storage.
+    // Keeping both of them in the list is redundant.
+    if (wasLastArray_ && obj->IsGrowableObjectArray()) {
+      wasLastArray_ = false;
+      return true;
+    }
+    wasLastArray_ = obj->IsArray();
+    return false;
+  }
+
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     if (it->Get() != obj_) {
       if (ShouldSkip(it->Get())) {
         return kBacktrack;
       } else {
         return kProceed;
       }
     } else {
       HANDLESCOPE(thread_);
       Object& current = Object::Handle();
       Smi& offset_from_parent = Smi::Handle();
+      StartList();
       do {
+        if (ShouldOverwrite(it->Get())) {
+          --length_;
+        }
         intptr_t obj_index = length_ * 2;
         intptr_t offset_index = obj_index + 1;
         if (!path_.IsNull() && offset_index < path_.Length()) {
           current = it->Get();
           path_.SetAt(obj_index, current);
           offset_from_parent = Smi::New(it->OffsetFromParentInWords());
           path_.SetAt(offset_index, offset_from_parent);
         }
         ++length_;
-      } while (it->MoveToParent());
+      } while (!ShouldStop(it->Get()) && it->MoveToParent());
       return kAbort;
     }
   }
 
  private:
   Thread* thread_;
   RawObject* obj_;
   const Array& path_;
   intptr_t length_;
+  bool wasLastArray_;
 };
 
 
 intptr_t ObjectGraph::RetainingPath(Object* obj, const Array& path) {
   NoSafepointScope no_safepoint_scope_;
   // To break the trivial path, the handle 'obj' is temporarily cleared during
   // the search, but restored before returning.
   RawObject* raw = obj->raw();
   *obj = Object::null();
   RetainingPathVisitor visitor(raw, path);
@@ skipping 161 matching lines @@
   {
     WritePointerVisitor ptr_writer(isolate(), stream);
     isolate()->IterateObjectPointers(&ptr_writer, false);
   }
   stream->WriteUnsigned(0);
   IterateObjects(&visitor);
   return visitor.count() + 1;  // + root
 }
 
 }  // namespace dart