Add a version of heap snapshots that use only fields and stack frames as roots and only include ins…

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 "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 3217 matching lines @@
 };
 
 
 static bool GetHeapMap(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   isolate->heap()->PrintHeapMapToJSONStream(isolate, js);
   return true;
 }
 
 
+static const char* snapshot_roots_names[] = {
+    "VM", "User", NULL,
+};
+
+
+static ObjectGraph::SnapshotRoots snapshot_roots_values[] = {
+    ObjectGraph::kVM, ObjectGraph::kUser,
+};
+
+
 static const MethodParameter* request_heap_snapshot_params[] = {
     RUNNABLE_ISOLATE_PARAMETER,
+    new EnumParameter("roots", false /* not required */, snapshot_roots_names),
     new BoolParameter("collectGarbage", false /* not required */), NULL,
 };
 
 
 static bool RequestHeapSnapshot(Thread* thread, JSONStream* js) {
+  ObjectGraph::SnapshotRoots roots = ObjectGraph::kVM;
+  const char* roots_arg = js->LookupParam("roots");
+  if (roots_arg != NULL) {
+    roots = EnumMapper(roots_arg, snapshot_roots_names, snapshot_roots_values);
+  }
   const bool collect_garbage =
       BoolParameter::Parse(js->LookupParam("collectGarbage"), true);
   if (Service::graph_stream.enabled()) {
-    Service::SendGraphEvent(thread, collect_garbage);
+    Service::SendGraphEvent(thread, roots, collect_garbage);
   }
   // TODO(koda): Provide some id that ties this request to async response(s).
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "OK");
   return true;
 }
 
 
-void Service::SendGraphEvent(Thread* thread, bool collect_garbage) {
+void Service::SendGraphEvent(Thread* thread,
+                             ObjectGraph::SnapshotRoots roots,
+                             bool collect_garbage) {
   uint8_t* buffer = NULL;
   WriteStream stream(&buffer, &allocator, 1 * MB);
   ObjectGraph graph(thread);
-  intptr_t node_count = graph.Serialize(&stream, collect_garbage);
+  intptr_t node_count = graph.Serialize(&stream, roots, collect_garbage);
 
   // Chrome crashes receiving a single tens-of-megabytes blob, so send the
   // snapshot in megabyte-sized chunks instead.
   const intptr_t kChunkSize = 1 * MB;
   intptr_t num_chunks =
       (stream.bytes_written() + (kChunkSize - 1)) / kChunkSize;
   for (intptr_t i = 0; i < num_chunks; i++) {
     JSONStream js;
     {
       JSONObject jsobj(&js);
@@ skipping 800 matching lines @@
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart