Port _echo, etc commands to RPC

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 1053 matching lines @@
     frame->PrintToJSONObject(&jsobj);
     // TODO(turnidge): Implement depth differently -- differentiate
     // inlined frames.
     jsobj.AddProperty("depth", i);
   }
   return true;
 }
 
 
 static bool HandleCommonEcho(JSONObject* jsobj, JSONStream* js) {
-  jsobj->AddProperty("type", "message");
-  PrintArgumentsAndOptions(*jsobj, js);
+  jsobj->AddProperty("type", "_EchoResponse");
+  if (js->HasOption("text")) {
+    jsobj->AddProperty("text", js->LookupOption("text"));
+  }
   return true;
 }
 
 
-void Service::SendEchoEvent(Isolate* isolate) {
+void Service::SendEchoEvent(Isolate* isolate, const char* text) {
   JSONStream js;
   {
     JSONObject jsobj(&js);
     jsobj.AddProperty("type", "ServiceEvent");
-    jsobj.AddPropertyF("id", "_echoEvent");
     jsobj.AddProperty("eventType", "_Echo");
     jsobj.AddProperty("isolate", isolate);
+    if (text != NULL) {
+      jsobj.AddProperty("text", text);
+    }
   }
   const String& message = String::Handle(String::New(js.ToCString()));
   uint8_t data[] = {0, 128, 255};
   // TODO(koda): Add 'testing' event family.
   SendEvent(kEventFamilyDebug, message, data, sizeof(data));
 }
 
 
+static bool HandleIsolateTriggerEchoEvent(Isolate* isolate, JSONStream* js) {
+  Service::SendEchoEvent(isolate, js->LookupOption("text"));
+  JSONObject jsobj(js);
+  return HandleCommonEcho(&jsobj, js);
+}
+
+
 static bool HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
-  jsobj.AddProperty("id", "_echo");
-  if (js->num_arguments() == 2 && strcmp(js->GetArgument(1), "event") == 0) {
-    Service::SendEchoEvent(isolate);
-  }
   return HandleCommonEcho(&jsobj, js);
 }
 
 
 // Print an error message if there is no ID argument.
 #define REQUIRE_COLLECTION_ID(collection)                                      \
   if (js->num_arguments() == 1) {                                              \
     PrintError(js, "Must specify collection object id: /%s/id", collection);   \
     return true;                                                               \
   }
@@ skipping 1764 matching lines @@
   {
     NoGCScope no_gc;
     ContainsAddressVisitor visitor(isolate, addr);
     object = isolate->heap()->FindObject(&visitor);
   }
   object.PrintJSON(js, ref);
   return true;
 }
 
 
-static bool HandleMalformedJson(Isolate* isolate, JSONStream* js) {
+static bool HandleIsolateRespondWithMalformedJson(Isolate* isolate,
+                                                  JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("a", "a");
   JSONObject jsobj1(js);
   jsobj1.AddProperty("a", "a");
   JSONObject jsobj2(js);
   jsobj2.AddProperty("a", "a");
   JSONObject jsobj3(js);
   jsobj3.AddProperty("a", "a");
   return true;
 }
 
 
-static bool HandleMalformedObject(Isolate* isolate, JSONStream* js) {
+static bool HandleIsolateRespondWithMalformedObject(Isolate* isolate,
+                                                    JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers[] = {
-  { "_malformedjson", HandleMalformedJson },      // debug
-  { "_malformedobject", HandleMalformedObject },  // debug
-  { "_echo", HandleIsolateEcho },                 // debug
   { "", HandleIsolate },                          // getObject
   { "address", HandleAddress },                   // to do
   { "classes", HandleClasses },                   // getObject
   { "code", HandleCode },                         // getObject
   { "libraries", HandleLibraries },               // getObject
   { "metrics", HandleMetrics },                   // to do - complex?
   { "objects", HandleObjects },                   // getObject
   { "scripts", HandleScripts },                   // getObject
 };
 
@@ skipping 100 matching lines @@
   { "addBreakpoint", HandleIsolateAddBreakpoint },
   { "removeBreakpoint", HandleIsolateRemoveBreakpoint },
   { "getCoverage", HandleIsolateGetCoverage },
   { "eval", HandleIsolateEval },
   { "getRetainedSize", HandleIsolateGetRetainedSize },
   { "getRetainingPath", HandleIsolateGetRetainingPath },
   { "getInboundReferences", HandleIsolateGetInboundReferences },
   { "getInstances", HandleIsolateGetInstances },
   { "requestHeapSnapshot", HandleIsolateRequestHeapSnapshot },
   { "getClassList", HandleIsolateGetClassList },
-  { "getTypeArgumentsList", HandleIsolateGetTypeArgumentsList }
+  { "getTypeArgumentsList", HandleIsolateGetTypeArgumentsList },
+  { "_echo", HandleIsolateEcho },
+  { "_triggerEchoEvent", HandleIsolateTriggerEchoEvent },
+  { "_respondWithMalformedJson", HandleIsolateRespondWithMalformedJson },
+  { "_respondWithMalformedObject", HandleIsolateRespondWithMalformedObject },
 };
 
 
 static IsolateMessageHandler FindIsolateMessageHandlerNew(const char* command) {
   intptr_t num_message_handlers = sizeof(isolate_handlers_new) /
                                   sizeof(isolate_handlers_new[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const IsolateMessageHandlerEntry& entry = isolate_handlers_new[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
@@ skipping 142 matching lines @@
           js.PostReply();
         }
       }
     }
   }
 }
 
 
 static bool HandleRootEcho(JSONStream* js) {
   JSONObject jsobj(js);
-  jsobj.AddProperty("id", "_echo");
   return HandleCommonEcho(&jsobj, js);
 }
 
 
 class ServiceIsolateVisitor : public IsolateVisitor {
  public:
   explicit ServiceIsolateVisitor(JSONArray* jsarr)
       : jsarr_(jsarr) {
   }
 
@@ skipping 70 matching lines @@
         }
       }
     }
     return true;
   } else {
     PrintError(js, "Command too long");
     return true;
   }
 }
 
-
 static RootMessageHandlerEntry root_handlers[] = {
-  { "_echo", HandleRootEcho },
   { "vm", HandleVM },
   { "flags", HandleFlags },
 };
 
 
 static RootMessageHandler FindRootMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(root_handlers) /
                                   sizeof(root_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const RootMessageHandlerEntry& entry = root_handlers[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
     OS::Print("vm-service: No root message handler for <%s>.\n", command);
   }
   return NULL;
 }
 
 
 static RootMessageHandlerEntry root_handlers_new[] = {
   { "getVM", HandleVM },
+  { "_echo", HandleRootEcho },
 };
 
 
 static RootMessageHandler FindRootMessageHandlerNew(const char* command) {
   intptr_t num_message_handlers = sizeof(root_handlers_new) /
                                   sizeof(root_handlers_new[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const RootMessageHandlerEntry& entry = root_handlers_new[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
@@ skipping 170 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart