Added Editor stream and sendObjectToEditor RPC into Service Protocol

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 111 matching lines @@
 // These are the set of streams known to the core VM.
 StreamInfo Service::vm_stream("VM");
 StreamInfo Service::isolate_stream("Isolate");
 StreamInfo Service::debug_stream("Debug");
 StreamInfo Service::gc_stream("GC");
 StreamInfo Service::echo_stream("_Echo");
 StreamInfo Service::graph_stream("_Graph");
 StreamInfo Service::logging_stream("_Logging");
 StreamInfo Service::extension_stream("Extension");
 StreamInfo Service::timeline_stream("Timeline");
+StreamInfo Service::editor_stream("_Editor");
 
 static StreamInfo* streams_[] = {
     &Service::vm_stream,       &Service::isolate_stream,
     &Service::debug_stream,    &Service::gc_stream,
     &Service::echo_stream,     &Service::graph_stream,
     &Service::logging_stream,  &Service::extension_stream,
-    &Service::timeline_stream,
-};
+    &Service::timeline_stream, &Service::editor_stream};
 
 
 bool Service::ListenStream(const char* stream_id) {
   if (FLAG_trace_service) {
     OS::Print("vm-service: starting stream '%s'\n", stream_id);
   }
   intptr_t num_streams = sizeof(streams_) / sizeof(streams_[0]);
   for (intptr_t i = 0; i < num_streams; i++) {
     if (strcmp(stream_id, streams_[i]->id()) == 0) {
       streams_[i]->set_enabled(true);
@@ skipping 4046 matching lines @@
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
   ASSERT(!cls.IsNull());
   cls.SetTraceAllocation(enable);
   PrintSuccess(js);
   return true;
 }
 
+static const MethodParameter* send_object_to_editor_params[] = {
+    RUNNABLE_ISOLATE_PARAMETER, new StringParameter("editor", true),
+    new StringParameter("objectId", true), NULL,
+};
+
+static bool SendObjectToEditor(Thread* thread, JSONStream* js) {
+  // Handle heap objects.
+  ObjectIdRing::LookupResult lookup_result;
+  const Object& obj = Object::Handle(
+      LookupHeapObject(thread, js->LookupParam("objectId"), &lookup_result));

[rmacnak, 2017/06/27 16:47:56]

It looks like the only thing we do with the object is turn it back into an
objectId for the event. Should we just pass the objectId through?

[cbernaschina, 2017/06/27 17:03:25]

In the event it is sent as an ObjectRef.
Looking it up through the ObjectIdRing should guarantee a longer life for the
volatile ids.

[rmacnak, 2017/06/28 16:32:42]

Add a comment here explaining we're effectively refreshing the id here.

[cbernaschina, 2017/06/29 17:29:38]

Done.

+  if (obj.raw() != Object::sentinel().raw()) {
+    // We found a heap object for this id.  Return it.
+    if (Service::editor_stream.enabled()) {
+      ServiceEvent event(thread->isolate(),
+                         ServiceEvent::kEditorObjectSelected);
+      ServiceEvent::EditorEvent editor_event;
+      editor_event.object = &obj;
+      editor_event.editor = js->LookupParam("editor");
+      event.set_editor_event(editor_event);
+      Service::HandleEvent(&event);
+    }
+    PrintSuccess(js);
+    return true;
+  } else if (lookup_result == ObjectIdRing::kCollected) {
+    PrintSentinel(js, kCollectedSentinel);
+    return true;
+  } else if (lookup_result == ObjectIdRing::kExpired) {
+    PrintSentinel(js, kExpiredSentinel);
+    return true;
+  }
+  PrintInvalidParamError(js, "objectId");
+
+  return true;
+}
+
 
 // clang-format off
 static const ServiceMethodDescriptor service_methods_[] = {
   { "_dumpIdZone", DumpIdZone, NULL },
   { "_echo", Echo,
     NULL },
   { "_respondWithMalformedJson", RespondWithMalformedJson,
     NULL },
   { "_respondWithMalformedObject", RespondWithMalformedObject,
     NULL },
@@ skipping 98 matching lines @@
   { "setName", SetName,
     set_name_params },
   { "_setTraceClassAllocation", SetTraceClassAllocation,
     set_trace_class_allocation_params },
   { "setVMName", SetVMName,
     set_vm_name_params },
   { "_setVMTimelineFlags", SetVMTimelineFlags,
     set_vm_timeline_flags_params },
   { "_collectAllGarbage", CollectAllGarbage,
     collect_all_garbage_params },
+  { "_sendObjectToEditor", SendObjectToEditor,
+    send_object_to_editor_params },
 };
 // clang-format on
 
 const ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) / sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart