Allow root level requests in the vm service.

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 "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/heap_histogram.h"
 #include "vm/isolate.h"
 #include "vm/message.h"
 #include "vm/object.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 
 namespace dart {
 
-typedef void (*ServiceMessageHandler)(Isolate* isolate, JSONStream* stream);
+// A handler for a per-isolate request.  These handlers must call
+// PostReply in order to respond to the request.
+typedef void (*IsolateMessageHandler)(Isolate* isolate, JSONStream* stream);

[Cutch, 2014/01/09 23:03:23]

Why not have the handler functions return true to indicate that the stream
should be posted for reply? This should move all of the PostReply calls into
just one place. If the handler returns false it means the handler has forwarded
the message for asynchronous handling and will post the reply itself.

[turnidge, 2014/01/15 20:21:04]

Done.

 
-struct ServiceMessageHandlerEntry {
+struct IsolateMessageHandlerEntry {
   const char* command;
-  ServiceMessageHandler handler;
+  IsolateMessageHandler handler;
 };
 
-static ServiceMessageHandler FindServiceMessageHandler(const char* command);
+static IsolateMessageHandler FindIsolateMessageHandler(const char* command);
 
+// A handler for a root (vm-global) request.  These handlers do not
+// call PostReply.
+typedef void (*RootMessageHandler)(JSONStream* stream);
+
+struct RootMessageHandlerEntry {
+  const char* command;
+  RootMessageHandler handler;
+};
+
+static RootMessageHandler FindRootMessageHandler(const char* command);
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
-static void PostReply(const String& reply, const Instance& reply_port) {
+static void PostReply(JSONStream* js) {
+  Dart_Port reply_port = js->reply_port();
+  ASSERT(reply_port != ILLEGAL_PORT);
+  js->SetReplyPort(ILLEGAL_PORT);  // Prevent double replies.
+
+  const String& reply = String::Handle(String::New(js->ToCString()));
+  ASSERT(!reply.IsNull());
+
+  uint8_t* data = NULL;
+  MessageWriter writer(&data, &allocator);
+  writer.WriteMessage(reply);
+  PortMap::PostMessage(new Message(reply_port, data,
+                                   writer.BytesWritten(),
+                                   Message::kNormalPriority));
+}
+
+
+static void SetupJSONStream(JSONStream* js, Zone* zone,
+                            const Instance& reply_port,
+                            const GrowableObjectArray& path,
+                            const GrowableObjectArray& option_keys,
+                            const GrowableObjectArray& option_values) {
+  // Setup the reply port.
   const Object& id_obj = Object::Handle(
       DartLibraryCalls::PortGetId(reply_port));
   if (id_obj.IsError()) {
     Exceptions::PropagateError(Error::Cast(id_obj));
   }
   const Integer& id = Integer::Cast(id_obj);
   Dart_Port port = static_cast<Dart_Port>(id.AsInt64Value());
   ASSERT(port != ILLEGAL_PORT);
+  js->SetReplyPort(port);
 
-  uint8_t* data = NULL;
-  MessageWriter writer(&data, &allocator);
-  writer.WriteMessage(reply);
-  PortMap::PostMessage(new Message(port, data,
-                                   writer.BytesWritten(),
-                                   Message::kNormalPriority));
-}
-
-
-void Service::HandleServiceMessage(Isolate* isolate, const Instance& msg) {
-  ASSERT(isolate != NULL);
-  ASSERT(!msg.IsNull());
-  ASSERT(msg.IsGrowableObjectArray());
-
-  {
-    StackZone zone(isolate);
-    HANDLESCOPE(isolate);
-
-    const GrowableObjectArray& message = GrowableObjectArray::Cast(msg);
-    // Message is a list with three entries.
-    ASSERT(message.Length() == 4);
-
-    Instance& reply_port = Instance::Handle(isolate);
-    GrowableObjectArray& path = GrowableObjectArray::Handle(isolate);
-    GrowableObjectArray& option_keys = GrowableObjectArray::Handle(isolate);
-    GrowableObjectArray& option_values = GrowableObjectArray::Handle(isolate);
-    reply_port ^= message.At(0);
-    path ^= message.At(1);
-    option_keys ^= message.At(2);
-    option_values ^= message.At(3);
-
-    ASSERT(!path.IsNull());
-    ASSERT(!option_keys.IsNull());
-    ASSERT(!option_values.IsNull());
-    // Path always has at least one entry in it.
-    ASSERT(path.Length() > 0);
-    // Same number of option keys as values.
-    ASSERT(option_keys.Length() == option_values.Length());
-
-    String& pathSegment = String::Handle();
-    pathSegment ^= path.At(0);
-    ASSERT(!pathSegment.IsNull());
-
-    ServiceMessageHandler handler =
-        FindServiceMessageHandler(pathSegment.ToCString());
-    ASSERT(handler != NULL);
-    {
-      JSONStream js;
-
-      // Setup JSONStream arguments and options. The arguments and options
-      // are zone allocated and will be freed immediately after handling the
-      // message.
-      Zone* zoneAllocator = zone.GetZone();
-      const char** arguments = zoneAllocator->Alloc<const char*>(path.Length());
-      String& string_iterator = String::Handle();
-      for (intptr_t i = 0; i < path.Length(); i++) {
-        string_iterator ^= path.At(i);
-        arguments[i] =
-            zoneAllocator->MakeCopyOfString(string_iterator.ToCString());
-      }
-      js.SetArguments(arguments, path.Length());
-      if (option_keys.Length() > 0) {
-        const char** option_keys_native =
-            zoneAllocator->Alloc<const char*>(option_keys.Length());
-        const char** option_values_native =
-            zoneAllocator->Alloc<const char*>(option_keys.Length());
-        for (intptr_t i = 0; i < option_keys.Length(); i++) {
-          string_iterator ^= option_keys.At(i);
-          option_keys_native[i] =
-              zoneAllocator->MakeCopyOfString(string_iterator.ToCString());
-          string_iterator ^= option_values.At(i);
-          option_values_native[i] =
-              zoneAllocator->MakeCopyOfString(string_iterator.ToCString());
-        }
-        js.SetOptions(option_keys_native, option_values_native,
-                      option_keys.Length());
-      }
-
-      handler(isolate, &js);
-      const String& reply = String::Handle(String::New(js.ToCString()));
-      ASSERT(!reply.IsNull());
-      PostReply(reply, reply_port);
+  // Setup JSONStream arguments and options. The arguments and options
+  // are zone allocated and will be freed immediately after handling the
+  // message.
+  const char** arguments = zone->Alloc<const char*>(path.Length());
+  String& string_iterator = String::Handle();
+  for (intptr_t i = 0; i < path.Length(); i++) {
+    string_iterator ^= path.At(i);
+    arguments[i] = zone->MakeCopyOfString(string_iterator.ToCString());
+  }
+  js->SetArguments(arguments, path.Length());
+  if (option_keys.Length() > 0) {
+    const char** option_keys_native =
+        zone->Alloc<const char*>(option_keys.Length());
+    const char** option_values_native =
+        zone->Alloc<const char*>(option_keys.Length());
+    for (intptr_t i = 0; i < option_keys.Length(); i++) {
+      string_iterator ^= option_keys.At(i);
+      option_keys_native[i] =
+          zone->MakeCopyOfString(string_iterator.ToCString());
+      string_iterator ^= option_values.At(i);
+      option_values_native[i] =
+          zone->MakeCopyOfString(string_iterator.ToCString());
     }
+    js->SetOptions(option_keys_native, option_values_native,
+                  option_keys.Length());
   }
 }
 
 
 static void PrintArgumentsAndOptions(const JSONObject& obj, JSONStream* js) {
   JSONObject jsobj(&obj, "message");
   {
     JSONArray jsarr(&jsobj, "arguments");
     for (intptr_t i = 0; i < js->num_arguments(); i++) {
       jsarr.AddValue(js->GetArgument(i));
     }
   }
   {
     JSONArray jsarr(&jsobj, "option_keys");
     for (intptr_t i = 0; i < js->num_options(); i++) {
       jsarr.AddValue(js->GetOptionKey(i));
     }
   }
   {
     JSONArray jsarr(&jsobj, "option_values");
     for (intptr_t i = 0; i < js->num_options(); i++) {
       jsarr.AddValue(js->GetOptionValue(i));
     }
   }
 }
 
 
-static void PrintGenericError(JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "Error");
-  jsobj.AddProperty("text", "Invalid request.");
-  PrintArgumentsAndOptions(jsobj, js);
-}
-
-
 static void PrintError(JSONStream* js, const char* format, ...) {
   Isolate* isolate = Isolate::Current();
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = isolate->current_zone()->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("text", buffer);
   PrintArgumentsAndOptions(jsobj, js);
 }
 
 
+void Service::HandleIsolateMessage(Isolate* isolate, const Instance& msg) {
+  ASSERT(isolate != NULL);
+  ASSERT(!msg.IsNull());
+  ASSERT(msg.IsGrowableObjectArray());
+
+  {
+    StackZone zone(isolate);
+    HANDLESCOPE(isolate);
+
+    const GrowableObjectArray& message = GrowableObjectArray::Cast(msg);
+    // Message is a list with four entries.
+    ASSERT(message.Length() == 4);
+
+    Instance& reply_port = Instance::Handle(isolate);
+    GrowableObjectArray& path = GrowableObjectArray::Handle(isolate);
+    GrowableObjectArray& option_keys = GrowableObjectArray::Handle(isolate);
+    GrowableObjectArray& option_values = GrowableObjectArray::Handle(isolate);
+    reply_port ^= message.At(0);
+    path ^= message.At(1);
+    option_keys ^= message.At(2);
+    option_values ^= message.At(3);
+
+    ASSERT(!path.IsNull());
+    ASSERT(!option_keys.IsNull());
+    ASSERT(!option_values.IsNull());
+    // Path always has at least one entry in it.
+    ASSERT(path.Length() > 0);
+    // Same number of option keys as values.
+    ASSERT(option_keys.Length() == option_values.Length());
+
+    String& pathSegment = String::Handle();
+    pathSegment ^= path.At(0);
+    ASSERT(!pathSegment.IsNull());
+
+    IsolateMessageHandler handler =
+        FindIsolateMessageHandler(pathSegment.ToCString());
+    {
+      JSONStream js;
+      SetupJSONStream(&js, zone.GetZone(),
+                      reply_port, path, option_keys, option_values);
+      if (handler == NULL) {
+        PrintError(&js, "Unrecognized path");
+        PostReply(&js);
+      } else {
+        handler(isolate, &js);
+      }
+    }
+  }
+}
+
+
 static void HandleName(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "IsolateName");
-  jsobj.AddProperty("id", static_cast<intptr_t>(isolate->main_port()));
-  jsobj.AddProperty("name", isolate->name());
+  {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "IsolateName");
+    jsobj.AddProperty("id", static_cast<intptr_t>(isolate->main_port()));
+    jsobj.AddProperty("name", isolate->name());
+  }
+  PostReply(js);
 }
 
 
 static void HandleStackTrace(Isolate* isolate, JSONStream* js) {
-  DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "StackTrace");
-  JSONArray jsarr(&jsobj, "members");
-  intptr_t n_frames = stack->Length();
-  String& function = String::Handle();
-  Script& script = Script::Handle();
-  for (int i = 0; i < n_frames; i++) {
-    ActivationFrame* frame = stack->FrameAt(i);
-    script ^= frame->SourceScript();
-    function ^= frame->function().UserVisibleName();
-    JSONObject jsobj(&jsarr);
-    jsobj.AddProperty("name", function.ToCString());
-    jsobj.AddProperty("script", script);
-    jsobj.AddProperty("line", frame->LineNumber());
-    jsobj.AddProperty("function", frame->function());
-    jsobj.AddProperty("code", frame->code());
+  {
+    DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "StackTrace");
+    JSONArray jsarr(&jsobj, "members");
+    intptr_t n_frames = stack->Length();
+    String& function = String::Handle();
+    Script& script = Script::Handle();
+    for (int i = 0; i < n_frames; i++) {
+      ActivationFrame* frame = stack->FrameAt(i);
+      script ^= frame->SourceScript();
+      function ^= frame->function().UserVisibleName();
+      JSONObject jsobj(&jsarr);
+      jsobj.AddProperty("name", function.ToCString());
+      jsobj.AddProperty("script", script);
+      jsobj.AddProperty("line", frame->LineNumber());
+      jsobj.AddProperty("function", frame->function());
+      jsobj.AddProperty("code", frame->code());
+    }
   }
+  PostReply(js);
 }
 
 
 static void HandleObjectHistogram(Isolate* isolate, JSONStream* js) {
   ObjectHistogram* histogram = Isolate::Current()->object_histogram();
   if (histogram == NULL) {
-    JSONObject jsobj(js);
-    jsobj.AddProperty("type", "Error");
-    jsobj.AddProperty("text", "Run with --print_object_histogram");
+    {
+      JSONObject jsobj(js);
+      jsobj.AddProperty("type", "Error");
+      jsobj.AddProperty("text", "Run with --print_object_histogram");
+    }
+    PostReply(js);
     return;
   }
   histogram->PrintToJSONStream(js);
+  PostReply(js);
 }
 
 
-static void HandleEcho(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "message");
-  PrintArgumentsAndOptions(jsobj, js);
+static void HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
+  {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "message");
+    PrintArgumentsAndOptions(jsobj, js);
+  }
+  PostReply(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);  \
+    PrintError(js, "Must specify collection object id: /%s/id", collection);   \
     return;                                                                   \
   }
 
 
 #define CHECK_COLLECTION_ID_BOUNDS(collection, length, arg, id, js)            \
   if (!GetIntegerId(arg, &id)) {                                               \
     PrintError(js, "Must specify collection object id: %s/id", collection);    \
     return;                                                                    \
   }                                                                            \
   if ((id < 0) || (id >= length)) {                                            \
@@ skipping 43 matching lines @@
   *id = r;
   return true;
 }
 
 
 static void HandleClassesClosures(Isolate* isolate, const Class& cls,
                                   JSONStream* js) {
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
+    PostReply(js);
     return;
   }
   if (!GetIntegerId(js->GetArgument(3), &id)) {
     PrintError(js, "Must specify collection object id: closures/id");
+    PostReply(js);
     return;
   }
   Function& func = Function::Handle();
   func ^= cls.ClosureFunctionFromIndex(id);
   if (func.IsNull()) {
     PrintError(js, "Closure function %" Pd " not found", id);
+    PostReply(js);
     return;
   }
   func.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleClassesDispatchers(Isolate* isolate, const Class& cls,
                                      JSONStream* js) {
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
+    PostReply(js);
     return;
   }
   if (!GetIntegerId(js->GetArgument(3), &id)) {
     PrintError(js, "Must specify collection object id: dispatchers/id");
+    PostReply(js);
     return;
   }
   Function& func = Function::Handle();
   func ^= cls.InvocationDispatcherFunctionFromIndex(id);
   if (func.IsNull()) {
     PrintError(js, "Dispatcher %" Pd " not found", id);
+    PostReply(js);
     return;
   }
   func.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleClassesFunctions(Isolate* isolate, const Class& cls,
                                    JSONStream* js) {
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
+    PostReply(js);
     return;
   }
   if (!GetIntegerId(js->GetArgument(3), &id)) {
     PrintError(js, "Must specify collection object id: functions/id");
+    PostReply(js);
     return;
   }
   Function& func = Function::Handle();
   func ^= cls.FunctionFromIndex(id);
   if (func.IsNull()) {
     PrintError(js, "Function %" Pd " not found", id);
+    PostReply(js);
     return;
   }
   func.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleClassesImplicitClosures(Isolate* isolate, const Class& cls,
                                           JSONStream* js) {
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
+    PostReply(js);
     return;
   }
   if (!GetIntegerId(js->GetArgument(3), &id)) {
     PrintError(js, "Must specify collection object id: implicit_closures/id");
+    PostReply(js);
     return;
   }
   Function& func = Function::Handle();
   func ^= cls.ImplicitClosureFunctionFromIndex(id);
   if (func.IsNull()) {
     PrintError(js, "Implicit closure function %" Pd " not found", id);
+    PostReply(js);
     return;
   }
   func.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleClassesFields(Isolate* isolate, const Class& cls,
                                 JSONStream* js) {
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
+    PostReply(js);
     return;
   }
   if (!GetIntegerId(js->GetArgument(3), &id)) {
     PrintError(js, "Must specify collection object id: fields/id");
+    PostReply(js);
     return;
   }
   Field& field = Field::Handle(cls.FieldFromIndex(id));
   if (field.IsNull()) {
     PrintError(js, "Field %" Pd " not found", id);
+    PostReply(js);
     return;
   }
   field.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleClasses(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     ClassTable* table = isolate->class_table();
     table->PrintToJSONStream(js);
+    PostReply(js);
     return;
   }
   ASSERT(js->num_arguments() >= 2);
   intptr_t id;
   if (!GetIntegerId(js->GetArgument(1), &id)) {
     PrintError(js, "Must specify collection object id: /classes/id");
+    PostReply(js);
     return;
   }
   ClassTable* table = isolate->class_table();
   if (!table->IsValidIndex(id)) {
     PrintError(js, "%" Pd " is not a valid class id.", id);;
+    PostReply(js);
     return;
   }
   Class& cls = Class::Handle(table->At(id));
   if (js->num_arguments() == 2) {
     cls.PrintToJSONStream(js, false);
+    PostReply(js);
     return;
   } else if (js->num_arguments() >= 3) {
     const char* second = js->GetArgument(2);
     if (!strcmp(second, "closures")) {
       HandleClassesClosures(isolate, cls, js);
     } else if (!strcmp(second, "fields")) {
       HandleClassesFields(isolate, cls, js);
     } else if (!strcmp(second, "functions")) {
       HandleClassesFunctions(isolate, cls, js);
     } else if (!strcmp(second, "implicit_closures")) {
       HandleClassesImplicitClosures(isolate, cls, js);
     } else if (!strcmp(second, "dispatchers")) {
       HandleClassesDispatchers(isolate, cls, js);
     } else {
       PrintError(js, "Invalid sub collection %s", second);
+      PostReply(js);
     }
     return;
   }
   UNREACHABLE();
 }
 
 
 static void HandleLibrary(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     const Library& lib =
         Library::Handle(isolate->object_store()->root_library());
     lib.PrintToJSONStream(js, false);
+    PostReply(js);
     return;
   }
-  PrintGenericError(js);
+  PrintError(js, "Command too long");
+  PostReply(js);
 }
 
 
 static void HandleLibraries(Isolate* isolate, JSONStream* js) {
   // TODO(johnmccutchan): Support fields and functions on libraries.
   REQUIRE_COLLECTION_ID("libraries");
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
   ASSERT(!libs.IsNull());
   intptr_t id = 0;
   CHECK_COLLECTION_ID_BOUNDS("libraries", libs.Length(), js->GetArgument(1),
                              id, js);
   Library& lib = Library::Handle();
   lib ^= libs.At(id);
   ASSERT(!lib.IsNull());
   lib.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleObjects(Isolate* isolate, JSONStream* js) {
   REQUIRE_COLLECTION_ID("objects");
   ASSERT(js->num_arguments() >= 2);
   ObjectIdRing* ring = isolate->object_id_ring();
   ASSERT(ring != NULL);
   intptr_t id = -1;
   if (!GetIntegerId(js->GetArgument(1), &id)) {
     Object::null_object().PrintToJSONStream(js, false);
+    PostReply(js);
     return;
   }
   Object& obj = Object::Handle(ring->GetObjectForId(id));
   obj.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 
 static void HandleScriptsEnumerate(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "ScriptList");
   {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "ScriptList");
     JSONArray members(&jsobj, "members");
     const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
     int num_libs = libs.Length();
     Library &lib = Library::Handle();
     Script& script = Script::Handle();
     for (intptr_t i = 0; i < num_libs; i++) {
       lib ^= libs.At(i);
       ASSERT(!lib.IsNull());
       ASSERT(Smi::IsValid(lib.index()));
       const Array& loaded_scripts = Array::Handle(lib.LoadedScripts());
       ASSERT(!loaded_scripts.IsNull());
       intptr_t num_scripts = loaded_scripts.Length();
       for (intptr_t i = 0; i < num_scripts; i++) {
         script ^= loaded_scripts.At(i);
         members.AddValue(script);
       }
     }
   }
+  PostReply(js);
 }
 
 
 static void HandleScriptsFetch(Isolate* isolate, JSONStream* js) {
   const GrowableObjectArray& libs =
     GrowableObjectArray::Handle(isolate->object_store()->libraries());
   int num_libs = libs.Length();
   Library &lib = Library::Handle();
   Script& script = Script::Handle();
   String& url = String::Handle();
   const String& id = String::Handle(String::New(js->GetArgument(1)));
   ASSERT(!id.IsNull());
   // The id is the url of the script % encoded, decode it.
   String& requested_url = String::Handle(String::DecodeURI(id));
   for (intptr_t i = 0; i < num_libs; i++) {
     lib ^= libs.At(i);
     ASSERT(!lib.IsNull());
     ASSERT(Smi::IsValid(lib.index()));
     const Array& loaded_scripts = Array::Handle(lib.LoadedScripts());
     ASSERT(!loaded_scripts.IsNull());
     intptr_t num_scripts = loaded_scripts.Length();
     for (intptr_t i = 0; i < num_scripts; i++) {
       script ^= loaded_scripts.At(i);
       ASSERT(!script.IsNull());
       url ^= script.url();
       if (url.Equals(requested_url)) {
         script.PrintToJSONStream(js, false);
+        PostReply(js);
         return;
       }
     }
   }
   PrintError(js, "Cannot find script %s\n", requested_url.ToCString());
+  PostReply(js);
 }
 
 
 static void HandleScripts(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     // Enumerate all scripts.
     HandleScriptsEnumerate(isolate, js);
   } else if (js->num_arguments() == 2) {
     // Fetch specific script.
     HandleScriptsFetch(isolate, js);
   } else {
     PrintError(js, "Command too long");
+    PostReply(js);
   }
 }
 
 
 static void HandleDebug(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     PrintError(js, "Must specify a subcommand");
+    PostReply(js);
     return;
   }
   const char* command = js->GetArgument(1);
   if (!strcmp(command, "breakpoints")) {
     if (js->num_arguments() == 2) {
       // Print breakpoint list.
-      JSONObject jsobj(js);
-      jsobj.AddProperty("type", "BreakpointList");
-      JSONArray jsarr(&jsobj, "breakpoints");
-      isolate->debugger()->PrintBreakpointsToJSONArray(&jsarr);
-
+      {
+        JSONObject jsobj(js);
+        jsobj.AddProperty("type", "BreakpointList");
+        JSONArray jsarr(&jsobj, "breakpoints");
+        isolate->debugger()->PrintBreakpointsToJSONArray(&jsarr);
+      }
+      PostReply(js);
+      return;
     } else if (js->num_arguments() == 3) {
       // Print individual breakpoint.
       intptr_t id = 0;
       SourceBreakpoint* bpt = NULL;
       if (GetIntegerId(js->GetArgument(2), &id)) {
         bpt = isolate->debugger()->GetBreakpointById(id);
       }
       if (bpt != NULL) {
         bpt->PrintToJSONStream(js);
+        PostReply(js);
+        return;
       } else {
         PrintError(js, "Unrecognized breakpoint id %s", js->GetArgument(2));
+        PostReply(js);
+        return;
       }
-
     } else {
       PrintError(js, "Command too long");
+      PostReply(js);
+      return;
     }
   } else {
     PrintError(js, "Unrecognized subcommand '%s'", js->GetArgument(1));
+    PostReply(js);
+    return;
   }
 }
 
 
-static void HandleCpu(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "CPU");
-  jsobj.AddProperty("architecture", CPU::Id());
-}
-
-
 static void HandleCode(Isolate* isolate, JSONStream* js) {
   REQUIRE_COLLECTION_ID("code");
   uintptr_t pc;
   if (!GetUnsignedIntegerId(js->GetArgument(1), &pc, 16)) {
     PrintError(js, "Must specify code address: code/c0deadd0.");
+    PostReply(js);
     return;
   }
   Code& code = Code::Handle(Code::LookupCode(pc));
   if (code.IsNull()) {
     PrintError(js, "Could not find code at %" Px "", pc);
+    PostReply(js);
     return;
   }
   code.PrintToJSONStream(js, false);
+  PostReply(js);
 }
 
 
 static void HandleProfile(Isolate* isolate, JSONStream* js) {
   Profiler::PrintToJSONStream(isolate, js, true);
+  PostReply(js);
 }
 
 
-static ServiceMessageHandlerEntry __message_handlers[] = {
-  { "_echo", HandleEcho },
+static IsolateMessageHandlerEntry isolate_handlers[] = {
+  { "_echo", HandleIsolateEcho },
   { "classes", HandleClasses },
   { "code", HandleCode },
-  { "cpu", HandleCpu },
   { "debug", HandleDebug },
   { "libraries", HandleLibraries },
   { "library", HandleLibrary },
   { "name", HandleName },
   { "objecthistogram", HandleObjectHistogram},
   { "objects", HandleObjects },
   { "profile", HandleProfile },
   { "scripts", HandleScripts },
   { "stacktrace", HandleStackTrace },
 };
 
 
-static void HandleFallthrough(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "Error");
-  jsobj.AddProperty("text", "request not understood.");
-  PrintArgumentsAndOptions(jsobj, js);
-}
-
-
-static ServiceMessageHandler FindServiceMessageHandler(const char* command) {
-  intptr_t num_message_handlers = sizeof(__message_handlers) /
-                                  sizeof(__message_handlers[0]);
+static IsolateMessageHandler FindIsolateMessageHandler(const char* command) {
+  intptr_t num_message_handlers = sizeof(isolate_handlers) /
+                                  sizeof(isolate_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
-    const ServiceMessageHandlerEntry& entry = __message_handlers[i];
+    const IsolateMessageHandlerEntry& entry = isolate_handlers[i];
     if (!strcmp(command, entry.command)) {
       return entry.handler;
     }
   }
-  return HandleFallthrough;
+  return NULL;
+}
+
+
+void Service::HandleRootMessage(const Instance& msg) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(!msg.IsNull());
+  ASSERT(msg.IsGrowableObjectArray());
+
+  {
+    StackZone zone(isolate);
+    HANDLESCOPE(isolate);
+
+    const GrowableObjectArray& message = GrowableObjectArray::Cast(msg);
+    // Message is a list with four entries.
+    ASSERT(message.Length() == 4);
+
+    Instance& reply_port = Instance::Handle(isolate);
+    GrowableObjectArray& path = GrowableObjectArray::Handle(isolate);
+    GrowableObjectArray& option_keys = GrowableObjectArray::Handle(isolate);
+    GrowableObjectArray& option_values = GrowableObjectArray::Handle(isolate);
+    reply_port ^= message.At(0);
+    path ^= message.At(1);
+    option_keys ^= message.At(2);
+    option_values ^= message.At(3);
+
+    ASSERT(!path.IsNull());
+    ASSERT(!option_keys.IsNull());
+    ASSERT(!option_values.IsNull());
+    // Path always has at least one entry in it.
+    ASSERT(path.Length() > 0);
+    // Same number of option keys as values.
+    ASSERT(option_keys.Length() == option_values.Length());
+
+    String& pathSegment = String::Handle();
+    pathSegment ^= path.At(0);
+    ASSERT(!pathSegment.IsNull());
+
+    RootMessageHandler handler =
+        FindRootMessageHandler(pathSegment.ToCString());
+    {
+      JSONStream js;
+      SetupJSONStream(&js, zone.GetZone(),
+                      reply_port, path, option_keys, option_values);
+      if (handler == NULL) {
+        PrintError(&js, "Unrecognized path");
+        PostReply(&js);
+      } else {
+        handler(&js);
+      }
+    }
+  }
+}
+
+
+static void HandleRootEcho(JSONStream* js) {
+  {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "message");
+    PrintArgumentsAndOptions(jsobj, js);
+  }
+  PostReply(js);
+}
+
+
+static void HandleCpu(JSONStream* js) {
+  {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "CPU");
+    jsobj.AddProperty("architecture", CPU::Id());
+  }
+  PostReply(js);
+}
+
+
+static RootMessageHandlerEntry root_handlers[] = {
+  { "_echo", HandleRootEcho },
+  { "cpu", HandleCpu },
+};
+
+
+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)) {
+      return entry.handler;
+    }
+  }
+  return NULL;
 }
 
 }  // namespace dart