Retaining path in Observatory.

runtime/vm/service.cc

 // Copyright (c) 2013, 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/service.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 860 matching lines @@
         return true;
       }
     }
     return false;
   } else {
     return !obj.IsInstance();
   }
 }
 
 
+// Takes an Object* only because RetainingPath temporarily clears it.
 static bool HandleInstanceCommands(Isolate* isolate,
-                                   const Object& obj,
+                                   Object* obj,
                                    JSONStream* js,
                                    intptr_t arg_pos) {
   ASSERT(js->num_arguments() > arg_pos);
   const char* action = js->GetArgument(arg_pos);
   if (strcmp(action, "eval") == 0) {
     if (js->num_arguments() > (arg_pos + 1)) {
       PrintError(js, "expected at most %" Pd " arguments but found %" Pd "\n",
                  arg_pos + 1,
                  js->num_arguments());
       return true;
     }
-    if (obj.IsNull()) {
+    if (obj->IsNull()) {
       PrintErrorWithKind(js, "EvalCollected",
                          "attempt to evaluate against collected object\n",
                          js->num_arguments());
       return true;
     }
-    if (obj.raw() == Object::sentinel().raw()) {
+    if (obj->raw() == Object::sentinel().raw()) {
       PrintErrorWithKind(js, "EvalExpired",
                          "attempt to evaluate against expired object\n",
                          js->num_arguments());
       return true;
     }
-    if (ContainsNonInstance(obj)) {
+    if (ContainsNonInstance(*obj)) {
       PrintError(js, "attempt to evaluate against internal VM object\n");
       return true;
     }
     const char* expr = js->LookupOption("expr");
     if (expr == NULL) {
       PrintError(js, "eval expects an 'expr' option\n",
                  js->num_arguments());
       return true;
     }
     const String& expr_str = String::Handle(isolate, String::New(expr));
-    ASSERT(obj.IsInstance());
-    const Instance& instance = Instance::Cast(obj);
+    ASSERT(obj->IsInstance());
+    const Instance& instance = Instance::Cast(*obj);
     const Object& result =
         Object::Handle(instance.Evaluate(expr_str,
                                          Array::empty_array(),
                                          Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   } else if (strcmp(action, "retained") == 0) {
     ObjectGraph graph(isolate);
-    intptr_t retained_size = graph.SizeRetainedByInstance(obj);
+    intptr_t retained_size = graph.SizeRetainedByInstance(*obj);
     const Object& result = Object::Handle(Integer::New(retained_size));
     result.PrintJSON(js, true);
     return true;
+  } else if (strcmp(action, "retaining_path") == 0) {
+    intptr_t limit;
+    if (!GetIntegerId(js->LookupOption("limit"), &limit)) {
+      PrintError(js, "retaining_path expects a 'limit' option\n",
+                 js->num_arguments());
+      return true;
+    }
+    ObjectGraph graph(isolate);
+    Array& path = Array::Handle(Array::New(limit));
+    intptr_t length = graph.RetainingPath(obj, path);
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "RetainingPath");
+    jsobj.AddProperty("id", "retaining_path");
+    jsobj.AddProperty("length", length);
+    JSONArray elements(&jsobj, "elements");
+    for (intptr_t i = 0; i < path.Length() && i < length; ++i) {
+      JSONObject jselement(&elements);
+      Object& element = Object::Handle();
+      element = path.At(i);
+      jselement.AddProperty("index", i);
+      jselement.AddProperty("value", element);
+    }
+    return true;
   }
 
   PrintError(js, "unrecognized action '%s'\n", action);
   return true;
 }
 
 
 static bool HandleClassesClosures(Isolate* isolate, const Class& cls,
                                   JSONStream* js) {
   intptr_t id;
@@ skipping 147 matching lines @@
   Type& type = Type::Handle();
   type ^= cls.CanonicalTypeFromIndex(id);
   if (type.IsNull()) {
     PrintError(js, "Canonical type %" Pd " not found", id);
     return true;
   }
   if (js->num_arguments() == 4) {
     type.PrintJSON(js, false);
     return true;
   }
-  return HandleInstanceCommands(isolate, type, js, 4);
+  return HandleInstanceCommands(isolate, &type, js, 4);
 }
 
 
 static bool HandleClassesRetained(Isolate* isolate, const Class& cls,
                                   JSONStream* js) {
   if (js->num_arguments() != 3) {
     PrintError(js, "Command too long");
     return true;
   }
   ObjectGraph graph(isolate);
@@ skipping 228 matching lines @@
       PrintPseudoNull(js, "objects/collected", "<collected>");
       return true;
     } else if (obj.raw() == Object::sentinel().raw()) {
       // The object id has expired.
       PrintPseudoNull(js, "objects/expired", "<expired>");
       return true;
     }
     obj.PrintJSON(js, false);
     return true;
   }
-  return HandleInstanceCommands(isolate, obj, js, 2);
+  return HandleInstanceCommands(isolate, &obj, js, 2);
 }
 
 
 static bool HandleScriptsEnumerate(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "ScriptList");
   jsobj.AddProperty("id", "scripts");
   JSONArray members(&jsobj, "members");
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
@@ skipping 685 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart