Finish moving service protocol to json 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 801 matching lines @@
 
 // A handler for a per-isolate request.
 //
 // If a handler returns true, the reply is complete and ready to be
 // posted.  If a handler returns false, then it is responsible for
 // posting the reply (this can be used for asynchronous delegation of
 // the response handling).
 typedef bool (*IsolateMessageHandler)(Isolate* isolate, JSONStream* stream);
 
 struct IsolateMessageHandlerEntry {
-  const char* command;
+  const char* method;
   IsolateMessageHandler handler;
 };
 
-static IsolateMessageHandler FindIsolateMessageHandler(const char* command);
-static IsolateMessageHandler FindIsolateMessageHandlerNew(const char* command);
+static IsolateMessageHandler FindIsolateMessageHandler(const char* method);
 
 
 // A handler for a root (vm-global) request.
 //
 // If a handler returns true, the reply is complete and ready to be
 // posted.  If a handler returns false, then it is responsible for
 // posting the reply (this can be used for asynchronous delegation of
 // the response handling).
 typedef bool (*RootMessageHandler)(JSONStream* stream);
 
 struct RootMessageHandlerEntry {
-  const char* command;
+  const char* method;
   RootMessageHandler handler;
 };
 
-static RootMessageHandler FindRootMessageHandler(const char* command);
-static RootMessageHandler FindRootMessageHandlerNew(const char* command);
+static RootMessageHandler FindRootMessageHandler(const char* method);
 
 
-static void PrintArgumentsAndOptions(const JSONObject& obj, JSONStream* js) {
+static void PrintRequest(const JSONObject& obj, JSONStream* js) {
   JSONObject jsobj(&obj, "request");
+  jsobj.AddProperty("method", js->method());
   {
-    JSONArray jsarr(&jsobj, "arguments");
-    for (intptr_t i = 0; i < js->num_arguments(); i++) {
-      jsarr.AddValue(js->GetArgument(i));
+    JSONArray jsarr(&jsobj, "param_keys");
+    for (intptr_t i = 0; i < js->num_params(); i++) {
+      jsarr.AddValue(js->GetParamKey(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));
+    JSONArray jsarr(&jsobj, "param_values");
+    for (intptr_t i = 0; i < js->num_params(); i++) {
+      jsarr.AddValue(js->GetParamValue(i));
     }
   }
 }
 
 
 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("message", buffer);
-  PrintArgumentsAndOptions(jsobj, js);
+  PrintRequest(jsobj, js);
 }
 
 
+static void PrintMissingParamError(JSONStream* js,
+                                   const char* param) {
+  PrintError(js, "%s expects the '%s' parameter",
+             js->method(), param);
+}
+
+
+static void PrintInvalidParamError(JSONStream* js,
+                                   const char* param) {
+  PrintError(js, "%s: invalid '%s' parameter: %s",
+             js->method(), param, js->LookupParam(param));
+}
+
+
 static void PrintErrorWithKind(JSONStream* js,
                                const char* kind,
                                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("id", "");
   jsobj.AddProperty("kind", kind);
   jsobj.AddProperty("message", buffer);
-  PrintArgumentsAndOptions(jsobj, js);
+  PrintRequest(jsobj, js);
 }
 
 
-void Service::HandleIsolateMessageNew(Isolate* isolate, const Array& msg) {
+void Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
   ASSERT(isolate != NULL);
   ASSERT(!msg.IsNull());
+  ASSERT(msg.Length() == 5);
 
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
 
     Instance& reply_port = Instance::Handle(isolate);
     String& method = String::Handle(isolate);
     Array& param_keys = Array::Handle(isolate);
     Array& param_values = Array::Handle(isolate);
     reply_port ^= msg.At(1);
     method ^= msg.At(2);
     param_keys ^= msg.At(3);
     param_values ^= msg.At(4);
 
     ASSERT(!method.IsNull());
     ASSERT(!param_keys.IsNull());
     ASSERT(!param_values.IsNull());
     ASSERT(param_keys.Length() == param_values.Length());
 
     if (!reply_port.IsSendPort()) {
       FATAL("SendPort expected.");
     }
 
     IsolateMessageHandler handler =
-        FindIsolateMessageHandlerNew(method.ToCString());
+        FindIsolateMessageHandler(method.ToCString());
     {
       JSONStream js;
-      js.SetupNew(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-                  method, param_keys, param_values);
+      js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
+               method, param_keys, param_values);
       if (handler == NULL) {
         // Check for an embedder handler.
         EmbedderServiceHandler* e_handler =
             FindIsolateEmbedderHandler(method.ToCString());
         if (e_handler != NULL) {
           EmbedderHandleMessage(e_handler, &js);
         } else {
-          if (FindRootMessageHandlerNew(method.ToCString()) != NULL) {
-            PrintError(&js, "%s expects no 'isolate' parameter\n",
-                       method.ToCString());
+          if (FindRootMessageHandler(method.ToCString()) != NULL) {
+            PrintMissingParamError(&js, "isolate");
           } else {
             PrintError(&js, "Unrecognized method: %s", method.ToCString());
           }
         }
         js.PostReply();
       } else {
         if (handler(isolate, &js)) {
           // Handler returns true if the reply is ready to be posted.
           // TODO(johnmccutchan): Support asynchronous replies.
           js.PostReply();
         }
       }
     }
   }
 }
 
 
-void Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
-  ASSERT(isolate != NULL);
-  ASSERT(!msg.IsNull());
-
-  {
-    StackZone zone(isolate);
-    HANDLESCOPE(isolate);
-
-    // Message is a list with five entries.
-    ASSERT(msg.Length() == 5);
-
-    Object& tmp = Object::Handle(isolate);
-    tmp = msg.At(2);
-    if (tmp.IsString()) {
-      return Service::HandleIsolateMessageNew(isolate, msg);
-    }
-
-    Instance& reply_port = Instance::Handle(isolate);
-    GrowableObjectArray& path = GrowableObjectArray::Handle(isolate);
-    Array& option_keys = Array::Handle(isolate);
-    Array& option_values = Array::Handle(isolate);
-    reply_port ^= msg.At(1);
-    path ^= msg.At(2);
-    option_keys ^= msg.At(3);
-    option_values ^= msg.At(4);
-
-    ASSERT(!path.IsNull());
-    ASSERT(!option_keys.IsNull());
-    ASSERT(!option_values.IsNull());
-    // Same number of option keys as values.
-    ASSERT(option_keys.Length() == option_values.Length());
-
-    if (!reply_port.IsSendPort()) {
-      FATAL("SendPort expected.");
-    }
-
-    String& path_segment = String::Handle();
-    if (path.Length() > 0) {
-      path_segment ^= path.At(0);
-    } else {
-      path_segment ^= Symbols::Empty().raw();
-    }
-    ASSERT(!path_segment.IsNull());
-    const char* path_segment_c = path_segment.ToCString();
-
-    IsolateMessageHandler handler =
-        FindIsolateMessageHandler(path_segment_c);
-    {
-      JSONStream js;
-      js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-               path, option_keys, option_values);
-      if (handler == NULL) {
-        // Check for an embedder handler.
-        EmbedderServiceHandler* e_handler =
-            FindIsolateEmbedderHandler(path_segment_c);
-        if (e_handler != NULL) {
-          EmbedderHandleMessage(e_handler, &js);
-        } else {
-          PrintError(&js, "Unrecognized path");
-        }
-        js.PostReply();
-      } else {
-        if (handler(isolate, &js)) {
-          // Handler returns true if the reply is ready to be posted.
-          // TODO(johnmccutchan): Support asynchronous replies.
-          js.PostReply();
-        }
-      }
-    }
-  }
-}
-
-
 static bool HandleIsolate(Isolate* isolate, JSONStream* js) {
   isolate->PrintJSON(js, false);
   return true;
 }
 
 
 static bool HandleIsolateGetStack(Isolate* isolate, JSONStream* js) {
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Stack");
   JSONArray jsarr(&jsobj, "frames");
   intptr_t num_frames = stack->Length();
   for (intptr_t i = 0; i < num_frames; i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     JSONObject jsobj(&jsarr);
     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", "_EchoResponse");
-  if (js->HasOption("text")) {
-    jsobj->AddProperty("text", js->LookupOption("text"));
+  if (js->HasParam("text")) {
+    jsobj->AddProperty("text", js->LookupParam("text"));
   }
   return true;
 }
 
 
 void Service::SendEchoEvent(Isolate* isolate, const char* text) {
   JSONStream js;
   {
     JSONObject jsobj(&js);
     jsobj.AddProperty("type", "ServiceEvent");
     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"));
+  Service::SendEchoEvent(isolate, js->LookupParam("text"));
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
 static bool HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   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;                                                               \
-  }
-
-
-#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 true;                                                               \
-  }                                                                            \
-  if ((id < 0) || (id >= length)) {                                            \
-    PrintError(js, "%s id (%" Pd ") must be in [0, %" Pd ").", collection, id, \
-                                                               length);        \
-    return true;                                                               \
-  }
-
-
 static bool GetIntegerId(const char* s, intptr_t* id, int base = 10) {
   if ((s == NULL) || (*s == '\0')) {
     // Empty string.
     return false;
   }
   if (id == NULL) {
     // No id pointer.
     return false;
   }
   intptr_t r = 0;
@@ skipping 530 matching lines @@
       // references to an object.
       path.SetAt(i * 2, Object::null_object());
     }
   }
   return true;
 }
 
 
 static bool HandleIsolateGetInboundReferences(Isolate* isolate,
                                               JSONStream* js) {
-  const char* target_id = js->LookupOption("targetId");
+  const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'targetId' option");
+    PrintMissingParamError(js, "targetId");
     return true;
   }
-  const char* limit_cstr = js->LookupOption("limit");
+  const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'limit' option");
+    PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
-  if (!GetIntegerId(js->LookupOption("limit"), &limit)) {
-    PrintError(js, "Invalid 'limit' option: %s", limit_cstr);
+  if (!GetIntegerId(limit_cstr, &limit)) {
+    PrintInvalidParamError(js, "limit");
     return true;
   }
 
   Object& obj = Object::Handle(isolate);
   ObjectIdRing::LookupResult lookup_result;
   {
     HANDLESCOPE(isolate);
     obj = LookupHeapObject(isolate, target_id, &lookup_result);
   }
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintErrorWithKind(
           js, "InboundReferencesCollected",
-          "attempt to find a retaining path for a collected object\n",
-          js->num_arguments());
+          "attempt to find a retaining path for a collected object\n");
       return true;
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintErrorWithKind(
           js, "InboundReferencesExpired",
-          "attempt to find a retaining path for an expired object\n",
-          js->num_arguments());
+          "attempt to find a retaining path for an expired object\n");
       return true;
     }
-    PrintError(js, "Invalid 'targetId' value: no object with id '%s'",
-               target_id);
+    PrintInvalidParamError(js, "targetId");
     return true;
   }
   return PrintInboundReferences(isolate, &obj, limit, js);
 }
 
 
 static bool PrintRetainingPath(Isolate* isolate,
                                Object* obj,
                                intptr_t limit,
                                JSONStream* js) {
@@ skipping 43 matching lines @@
   // after looking for a retaining path.
   for (intptr_t i = 0; i < limit; ++i) {
     path.SetAt(i * 2, Object::null_object());
   }
 
   return true;
 }
 
 static bool HandleIsolateGetRetainingPath(Isolate* isolate,
                                           JSONStream* js) {
-  const char* target_id = js->LookupOption("targetId");
+  const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'targetId' option");
+    PrintMissingParamError(js, "targetId");
     return true;
   }
-  const char* limit_cstr = js->LookupOption("limit");
+  const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'limit' option");
+    PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
-  if (!GetIntegerId(js->LookupOption("limit"), &limit)) {
-    PrintError(js, "Invalid 'limit' option: %s", limit_cstr);
+  if (!GetIntegerId(limit_cstr, &limit)) {
+    PrintInvalidParamError(js, "limit");
     return true;
   }
 
   Object& obj = Object::Handle(isolate);
   ObjectIdRing::LookupResult lookup_result;
   {
     HANDLESCOPE(isolate);
     obj = LookupHeapObject(isolate, target_id, &lookup_result);
   }
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintErrorWithKind(
           js, "RetainingPathCollected",
-          "attempt to find a retaining path for a collected object\n",
-          js->num_arguments());
+          "attempt to find a retaining path for a collected object\n");
       return true;
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintErrorWithKind(
           js, "RetainingPathExpired",
-          "attempt to find a retaining path for an expired object\n",
-          js->num_arguments());
+          "attempt to find a retaining path for an expired object\n");
       return true;
     }
-    PrintError(js, "Invalid 'targetId' value: no object with id '%s'",
-               target_id);
+    PrintInvalidParamError(js, "targetId");
     return true;
   }
   return PrintRetainingPath(isolate, &obj, limit, js);
 }
 
 
 static bool HandleIsolateGetRetainedSize(Isolate* isolate, JSONStream* js) {
-  const char* target_id = js->LookupOption("targetId");
+  const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'targetId' option");
+    PrintMissingParamError(js, "targetId");
     return true;
   }
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id,
                                                 &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintErrorWithKind(
           js, "RetainedCollected",
-          "attempt to calculate size retained by a collected object\n",
-          js->num_arguments());
+          "attempt to calculate size retained by a collected object\n");
       return true;
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintErrorWithKind(
           js, "RetainedExpired",
-          "attempt to calculate size retained by an expired object\n",
-          js->num_arguments());
+          "attempt to calculate size retained by an expired object\n");
       return true;
     }
-    PrintError(js, "Invalid 'targetId' value: no object with id '%s'",
-               target_id);
+    PrintInvalidParamError(js, "targetId");
     return true;
   }
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     ObjectGraph graph(isolate);
     intptr_t retained_size = graph.SizeRetainedByClass(cls.id());
     const Object& result = Object::Handle(Integer::New(retained_size));
     result.PrintJSON(js, true);
     return true;
   }
   if (obj.IsInstance() || obj.IsNull()) {
     // We don't use Instance::Cast here because it doesn't allow null.
     ObjectGraph graph(isolate);
     intptr_t retained_size = graph.SizeRetainedByInstance(obj);
     const Object& result = Object::Handle(Integer::New(retained_size));
     result.PrintJSON(js, true);
     return true;
   }
-  PrintError(js, "Invalid 'targetId' value: id '%s' does not correspond to a "
-             "library, class, or instance", target_id);
-  return true;
-}
-
-
-static bool HandleClassesClosures(Isolate* isolate, const Class& cls,
-                                  JSONStream* js) {
-  intptr_t id;
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  if (!GetIntegerId(js->GetArgument(3), &id)) {
-    PrintError(js, "Must specify collection object id: closures/id");
-    return true;
-  }
-  Function& func = Function::Handle();
-  func ^= cls.ClosureFunctionFromIndex(id);
-  if (func.IsNull()) {
-    PrintError(js, "Closure function %" Pd " not found", id);
-    return true;
-  }
-  func.PrintJSON(js, false);
+  PrintError(js, "%s: Invalid 'targetId' parameter value: "
+             "id '%s' does not correspond to a "
+             "library, class, or instance", js->method(), target_id);
   return true;
 }
 
 
 static bool HandleIsolateEval(Isolate* isolate, JSONStream* js) {
-  const char* target_id = js->LookupOption("targetId");
+  const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'targetId' option");
+    PrintMissingParamError(js, "targetId");
     return true;
   }
-  const char* expr = js->LookupOption("expression");
+  const char* expr = js->LookupParam("expression");
   if (expr == NULL) {
-    PrintError(js, "Missing 'expression' option");
+    PrintMissingParamError(js, "expression");
     return true;
   }
   const String& expr_str = String::Handle(isolate, String::New(expr));
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id,
                                                 &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, "objects/collected", "<collected>");
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, "objects/expired", "<expired>");
     } else {
-      PrintError(js, "Invalid 'targetId' value: no object with id '%s'",
-                 target_id);
+      PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
     const Object& result = Object::Handle(lib.Evaluate(expr_str,
                                                        Array::empty_array(),
                                                        Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
@@ skipping 11 matching lines @@
     // We don't use Instance::Cast here because it doesn't allow null.
     Instance& instance = Instance::Handle(isolate);
     instance ^= obj.raw();
     const Object& result =
         Object::Handle(instance.Evaluate(expr_str,
                                          Array::empty_array(),
                                          Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
-  PrintError(js, "Invalid 'targetId' value: id '%s' does not correspond to a "
-             "library, class, or instance", target_id);
+  PrintError(js, "%s: Invalid 'targetId' parameter value: "
+             "id '%s' does not correspond to a "
+             "library, class, or instance", js->method(), target_id);
   return true;
 }
 
-
-static bool HandleClassesDispatchers(Isolate* isolate, const Class& cls,
-                                     JSONStream* js) {
-  intptr_t id;
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  if (!GetIntegerId(js->GetArgument(3), &id)) {
-    PrintError(js, "Must specify collection object id: dispatchers/id");
-    return true;
-  }
-  Function& func = Function::Handle();
-  func ^= cls.InvocationDispatcherFunctionFromIndex(id);
-  if (func.IsNull()) {
-    PrintError(js, "Dispatcher %" Pd " not found", id);
-    return true;
-  }
-  func.PrintJSON(js, false);
-  return true;
-}
-
-
-static bool HandleFunctionSetSource(
-    Isolate* isolate, const Class& cls, const Function& func, JSONStream* js) {
-  if (js->LookupOption("source") == NULL) {
-    PrintError(js, "set_source expects a 'source' option\n");
-    return true;
-  }
-  const String& source =
-      String::Handle(String::New(js->LookupOption("source")));
-  const Object& result = Object::Handle(
-      Parser::ParseFunctionFromSource(cls, source));
-  if (result.IsError()) {
-    Error::Cast(result).PrintJSON(js, false);
-    return true;
-  }
-  if (!result.IsFunction()) {
-    PrintError(js, "source did not compile to a function.\n");
-    return true;
-  }
-
-  // Replace function.
-  cls.RemoveFunction(func);
-  cls.AddFunction(Function::Cast(result));
-
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "Success");
-  jsobj.AddProperty("id", "");
-  return true;
-}
-
-
-static bool HandleClassesFunctions(Isolate* isolate, const Class& cls,
-                                   JSONStream* js) {
-  if (js->num_arguments() != 4 && js->num_arguments() != 5) {
-    PrintError(js, "Command should have 4 or 5 arguments");
-    return true;
-  }
-  const char* encoded_id = js->GetArgument(3);
-  String& id = String::Handle(isolate, String::New(encoded_id));
-  id = String::DecodeIRI(id);
-  if (id.IsNull()) {
-    PrintError(js, "Function id %s is malformed", encoded_id);
-    return true;
-  }
-  Function& func = Function::Handle(cls.LookupFunction(id));
-  if (func.IsNull()) {
-    PrintError(js, "Function %s not found", encoded_id);
-    return true;
-  }
-  if (js->num_arguments() == 4) {
-    func.PrintJSON(js, false);
-    return true;
-  } else {
-    const char* subcommand = js->GetArgument(4);
-    if (strcmp(subcommand, "set_source") == 0) {
-      return HandleFunctionSetSource(isolate, cls, func, js);
-    } else {
-      PrintError(js, "Invalid sub command %s", subcommand);
-      return true;
-    }
-  }
-  UNREACHABLE();
-  return true;
-}
-
-
-static bool HandleClassesImplicitClosures(Isolate* isolate, const Class& cls,
-                                          JSONStream* js) {
-  intptr_t id;
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  if (!GetIntegerId(js->GetArgument(3), &id)) {
-    PrintError(js, "Must specify collection object id: implicit_closures/id");
-    return true;
-  }
-  Function& func = Function::Handle();
-  func ^= cls.ImplicitClosureFunctionFromIndex(id);
-  if (func.IsNull()) {
-    PrintError(js, "Implicit closure function %" Pd " not found", id);
-    return true;
-  }
-  func.PrintJSON(js, false);
-  return true;
-}
-
-
-static bool HandleClassesFields(Isolate* isolate, const Class& cls,
-                                JSONStream* js) {
-  intptr_t id;
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  if (!GetIntegerId(js->GetArgument(3), &id)) {
-    PrintError(js, "Must specify collection object id: fields/id");
-    return true;
-  }
-  Field& field = Field::Handle(cls.FieldFromIndex(id));
-  if (field.IsNull()) {
-    PrintError(js, "Field %" Pd " not found", id);
-    return true;
-  }
-  field.PrintJSON(js, false);
-  return true;
-}
-
-
-static bool HandleClassesTypes(Isolate* isolate, const Class& cls,
-                               JSONStream* js) {
-  if (js->num_arguments() == 3) {
-    JSONObject jsobj(js);
-    jsobj.AddProperty("type", "TypeList");
-    JSONArray members(&jsobj, "members");
-    const intptr_t num_types = cls.NumCanonicalTypes();
-    Type& type = Type::Handle();
-    for (intptr_t i = 0; i < num_types; i++) {
-      type = cls.CanonicalTypeFromIndex(i);
-      members.AddValue(type);
-    }
-    return true;
-  }
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  ASSERT(js->num_arguments() == 4);
-  intptr_t id;
-  if (!GetIntegerId(js->GetArgument(3), &id)) {
-    PrintError(js, "Must specify collection object id: types/id");
-    return true;
-  }
-  Type& type = Type::Handle();
-  type ^= cls.CanonicalTypeFromIndex(id);
-  if (type.IsNull()) {
-    PrintError(js, "Canonical type %" Pd " not found", id);
-    return true;
-  }
-  type.PrintJSON(js, false);
-  return true;
-}
-
 
 class GetInstancesVisitor : public ObjectGraph::Visitor {
  public:
   GetInstancesVisitor(const Class& cls, const Array& storage)
       : cls_(cls), storage_(storage), count_(0) {}
 
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     RawObject* raw_obj = it->Get();
     if (raw_obj->IsFreeListElement()) {
       return kProceed;
@@ skipping 14 matching lines @@
   intptr_t count() const { return count_; }
 
  private:
   const Class& cls_;
   const Array& storage_;
   intptr_t count_;
 };
 
 
 static bool HandleIsolateGetInstances(Isolate* isolate, JSONStream* js) {
-  const char* target_id = js->LookupOption("classId");
+  const char* target_id = js->LookupParam("classId");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'classId' option");
+    PrintMissingParamError(js, "classId");
     return true;
   }
-  const char* limit_cstr = js->LookupOption("limit");
+  const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
-    PrintError(js, "Missing 'limit' option");
+    PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
-  if (!GetIntegerId(js->LookupOption("limit"), &limit)) {
-    PrintError(js, "Invalid 'limit' option: %s", limit_cstr);
+  if (!GetIntegerId(limit_cstr, &limit)) {
+    PrintInvalidParamError(js, "limit");
     return true;
   }
   const Object& obj =
       Object::Handle(LookupHeapObject(isolate, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw() ||
       !obj.IsClass()) {
-    PrintError(js, "Invalid 'classId' value: no class with id '%s'", target_id);
+    PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Cast(obj);
   Array& storage = Array::Handle(Array::New(limit));
   GetInstancesVisitor visitor(cls, storage);
   ObjectGraph graph(isolate);
   graph.IterateObjects(&visitor);
   intptr_t count = visitor.count();
   if (count < limit) {
     // Truncate the list using utility method for GrowableObjectArray.
     GrowableObjectArray& wrapper = GrowableObjectArray::Handle(
         GrowableObjectArray::New(storage));
     wrapper.SetLength(count);
     storage = Array::MakeArray(wrapper);
   }
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "InstanceSet");
   jsobj.AddProperty("id", "instance_set");
   jsobj.AddProperty("totalCount", count);
   jsobj.AddProperty("sampleCount", storage.Length());
   jsobj.AddProperty("sample", storage);
   return true;
 }
 
 
-static bool HandleClasses(Isolate* isolate, JSONStream* js) {
-  if (js->num_arguments() == 1) {
-    PrintError(js, "Invalid number of arguments.");
-    return true;
-  }
-  ASSERT(js->num_arguments() >= 2);
-  intptr_t id;
-  if (!GetIntegerId(js->GetArgument(1), &id)) {
-    PrintError(js, "Must specify collection object id: /classes/id");
-    return true;
-  }
-  ClassTable* table = isolate->class_table();
-  if (!table->IsValidIndex(id)) {
-    PrintError(js, "%" Pd " is not a valid class id.", id);
-    return true;
-  }
-  Class& cls = Class::Handle(table->At(id));
-  if (js->num_arguments() == 2) {
-    cls.PrintJSON(js, false);
-    return true;
-  } else if (js->num_arguments() >= 3) {
-    const char* second = js->GetArgument(2);
-    if (strcmp(second, "closures") == 0) {
-      return HandleClassesClosures(isolate, cls, js);
-    } else if (strcmp(second, "fields") == 0) {
-      return HandleClassesFields(isolate, cls, js);
-    } else if (strcmp(second, "functions") == 0) {
-      return HandleClassesFunctions(isolate, cls, js);
-    } else if (strcmp(second, "implicit_closures") == 0) {
-      return HandleClassesImplicitClosures(isolate, cls, js);
-    } else if (strcmp(second, "dispatchers") == 0) {
-      return HandleClassesDispatchers(isolate, cls, js);
-    } else if (strcmp(second, "types") == 0) {
-      return HandleClassesTypes(isolate, cls, js);
-    } else {
-      PrintError(js, "Invalid sub collection %s", second);
-      return true;
-    }
-  }
-  UNREACHABLE();
-  return true;
-}
-
-
 static bool HandleIsolateGetCoverage(Isolate* isolate, JSONStream* js) {
-  if (!js->HasOption("targetId")) {
+  if (!js->HasParam("targetId")) {
     CodeCoverage::PrintJSON(isolate, js, NULL);
     return true;
   }
-  const char* target_id = js->LookupOption("targetId");
+  const char* target_id = js->LookupParam("targetId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw()) {
-    PrintError(js, "Invalid 'targetId' value: no object with id '%s'",
-               target_id);
+    PrintInvalidParamError(js, "targetId");
     return true;
   }
   if (obj.IsScript()) {
     ScriptCoverageFilter sf(Script::Cast(obj));
     CodeCoverage::PrintJSON(isolate, js, &sf);
     return true;
   }
   if (obj.IsLibrary()) {
     LibraryCoverageFilter lf(Library::Cast(obj));
     CodeCoverage::PrintJSON(isolate, js, &lf);
     return true;
   }
   if (obj.IsClass()) {
     ClassCoverageFilter cf(Class::Cast(obj));
     CodeCoverage::PrintJSON(isolate, js, &cf);
     return true;
   }
   if (obj.IsFunction()) {
     FunctionCoverageFilter ff(Function::Cast(obj));
     CodeCoverage::PrintJSON(isolate, js, &ff);
     return true;
   }
-  PrintError(js, "Invalid 'targetId' value: id '%s' does not correspond to a "
-             "script, library, class, or function", target_id);
+  PrintError(js, "%s: Invalid 'targetId' parameter value: "
+             "id '%s' does not correspond to a "
+             "script, library, class, or function", js->method(), target_id);
   return true;
 }
 
 
 static bool HandleIsolateAddBreakpoint(Isolate* isolate, JSONStream* js) {
-  if (!js->HasOption("line")) {
-    PrintError(js, "Missing 'line' option");
+  if (!js->HasParam("line")) {
+    PrintMissingParamError(js, "line");
     return true;
   }
-  const char* line_option = js->LookupOption("line");
+  const char* line_param = js->LookupParam("line");
   intptr_t line = -1;
-  if (!GetIntegerId(line_option, &line)) {
-    PrintError(js, "Invalid 'line' value: %s is not an integer", line_option);
+  if (!GetIntegerId(line_param, &line)) {
+    PrintInvalidParamError(js, "line");
     return true;
   }
-  const char* script_id = js->LookupOption("script");
+  const char* script_id = js->LookupParam("script");
   Object& obj = Object::Handle(LookupHeapObject(isolate, script_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
-    PrintError(js, "Invalid 'script' value: no script with id '%s'", script_id);
+    PrintInvalidParamError(js, "script");
     return true;
   }
   const Script& script = Script::Cast(obj);
   const String& script_url = String::Handle(script.url());
   SourceBreakpoint* bpt =
       isolate->debugger()->SetBreakpointAtLine(script_url, line);
   if (bpt == NULL) {
-    PrintError(js, "Unable to set breakpoint at line %s", line_option);
+    PrintError(js, "Unable to set breakpoint at line %s", line_param);
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static bool HandleIsolateRemoveBreakpoint(Isolate* isolate, JSONStream* js) {
-  if (!js->HasOption("breakpointId")) {
-    PrintError(js, "Missing 'breakpointId' option");
+  if (!js->HasParam("breakpointId")) {
+    PrintMissingParamError(js, "breakpointId");
     return true;
   }
-  const char* bpt_id = js->LookupOption("breakpointId");
+  const char* bpt_id = js->LookupParam("breakpointId");
   SourceBreakpoint* bpt = LookupBreakpoint(isolate, bpt_id);
   if (bpt == NULL) {
     fprintf(stderr, "ERROR1");
-    PrintError(js, "Invalid 'breakpointId' value: no breakpoint with id '%s'",
-               bpt_id);
+    PrintInvalidParamError(js, "breakpointId");
     return true;
   }
   isolate->debugger()->RemoveBreakpoint(bpt->id());
 
     fprintf(stderr, "SUCCESS");
   // TODO(turnidge): Consider whether the 'Success' type is proper.
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Success");
   jsobj.AddProperty("id", "");
   return true;
 }
 
 
-static bool HandleLibrariesScripts(Isolate* isolate,
-                                   const Library& lib,
-                                   JSONStream* js) {
-  if (js->num_arguments() > 5) {
-    PrintError(js, "Command too long");
-    return true;
-  } else if (js->num_arguments() < 4) {
-    PrintError(js, "Must specify collection object id: scripts/id");
-    return true;
-  }
-  const String& id = String::Handle(String::New(js->GetArgument(3)));
-  ASSERT(!id.IsNull());
-  // The id is the url of the script % encoded, decode it.
-  const String& requested_url = String::Handle(String::DecodeIRI(id));
-  Script& script = Script::Handle();
-  String& script_url = String::Handle();
-  const Array& loaded_scripts = Array::Handle(lib.LoadedScripts());
-  ASSERT(!loaded_scripts.IsNull());
-  intptr_t i;
-  for (i = 0; i < loaded_scripts.Length(); i++) {
-    script ^= loaded_scripts.At(i);
-    ASSERT(!script.IsNull());
-    script_url ^= script.url();
-    if (script_url.Equals(requested_url)) {
-      break;
-    }
-  }
-  if (i == loaded_scripts.Length()) {
-    PrintError(js, "Script %s not found", requested_url.ToCString());
-    return true;
-  }
-  if (js->num_arguments() > 4) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  script.PrintJSON(js, false);
-  return true;
-}
-
-
-static bool 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());
-  if (js->num_arguments() == 2) {
-    lib.PrintJSON(js, false);
-    return true;
-  } else if (js->num_arguments() >= 3) {
-    const char* second = js->GetArgument(2);
-    if (strcmp(second, "scripts") == 0) {
-      return HandleLibrariesScripts(isolate, lib, js);
-    } else {
-      PrintError(js, "Invalid sub collection %s", second);
-      return true;
-    }
-  }
-  UNREACHABLE();
-  return true;
-}
-
-
 static RawClass* GetMetricsClass(Isolate* isolate) {
   const Library& prof_lib =
       Library::Handle(isolate, Library::ProfilerLibrary());
   ASSERT(!prof_lib.IsNull());
   const String& metrics_cls_name =
       String::Handle(isolate, String::New("Metrics"));
   ASSERT(!metrics_cls_name.IsNull());
   const Class& metrics_cls =
       Class::Handle(isolate, prof_lib.LookupClass(metrics_cls_name));
   ASSERT(!metrics_cls.IsNull());
@@ skipping 76 matching lines @@
     buffer->AddString(String::Cast(result).ToCString());
     return true;
   }
   PrintError(js, "Dart Metric %s not found\n", id);
   return true;
 }
 
 
 static bool HandleIsolateGetMetricList(Isolate* isolate, JSONStream* js) {
   bool native_metrics = false;
-  if (js->HasOption("type")) {
-    if (js->OptionIs("type", "Native")) {
+  if (js->HasParam("type")) {
+    if (js->ParamIs("type", "Native")) {
       native_metrics = true;
-    } else if (js->OptionIs("type", "Dart")) {
+    } else if (js->ParamIs("type", "Dart")) {
       native_metrics = false;
     } else {
-      PrintError(js, "Invalid 'type' option value: %s\n",
-                 js->LookupOption("type"));
+      PrintInvalidParamError(js, "type");
       return true;
     }
   } else {
-    PrintError(js, "Expected 'type' option.");
+    PrintMissingParamError(js, "type");
     return true;
   }
   if (native_metrics) {
     return HandleNativeMetricsList(isolate, js);
   }
   return HandleDartMetricsList(isolate, js);
 }
 
 
 static bool HandleIsolateGetMetric(Isolate* isolate, JSONStream* js) {
-  const char* metric_id = js->LookupOption("metricId");
+  const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
-    PrintError(js, "Expected 'metricId' option.");
+    PrintMissingParamError(js, "metricId");
     return true;
   }
   // Verify id begins with "metrics/".
   static const char* kMetricIdPrefix = "metrics/";
   static intptr_t kMetricIdPrefixLen = strlen(kMetricIdPrefix);
   if (strncmp(metric_id, kMetricIdPrefix, kMetricIdPrefixLen) != 0) {
     PrintError(js, "Metric %s not found\n", metric_id);
   }
   // Check if id begins with "metrics/native/".
   static const char* kNativeMetricIdPrefix = "metrics/native/";
   static intptr_t kNativeMetricIdPrefixLen = strlen(kNativeMetricIdPrefix);
   const bool native_metric =
       strncmp(metric_id, kNativeMetricIdPrefix, kNativeMetricIdPrefixLen) == 0;
   if (native_metric) {
     const char* id = metric_id + kNativeMetricIdPrefixLen;
     return HandleNativeMetric(isolate, js, id);
   }
   const char* id = metric_id + kMetricIdPrefixLen;
   return HandleDartMetric(isolate, js, id);
 }
 
 
 static bool HandleVMGetMetricList(JSONStream* js) {
   return false;
 }
 
 
 static bool HandleVMGetMetric(JSONStream* js) {
-  const char* metric_id = js->LookupOption("metricId");
+  const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
-    PrintError(js, "Expected 'metricId' option.");
+    PrintMissingParamError(js, "metricId");
   }
   return false;
 }
 
 
-static bool HandleObjects(Isolate* isolate, JSONStream* js) {
-  REQUIRE_COLLECTION_ID("objects");
-  if (js->num_arguments() != 2) {
-    PrintError(js, "expected at least 2 arguments but found %" Pd "\n",
-               js->num_arguments());
-    return true;
-  }
-  const char* arg = js->GetArgument(1);
-
-  // Handle special non-objects first.
-  if (strcmp(arg, "optimized-out") == 0) {
-    if (js->num_arguments() > 2) {
-      PrintError(js, "expected at most 2 arguments but found %" Pd "\n",
-                 js->num_arguments());
-    } else {
-      Symbols::OptimizedOut().PrintJSON(js, false);
-    }
-    return true;
-
-  } else if (strcmp(arg, "collected") == 0) {
-    if (js->num_arguments() > 2) {
-      PrintError(js, "expected at most 2 arguments but found %" Pd "\n",
-                 js->num_arguments());
-    } else {
-      PrintSentinel(js, "objects/collected", "<collected>");
-    }
-    return true;
-
-  } else if (strcmp(arg, "expired") == 0) {
-    if (js->num_arguments() > 2) {
-      PrintError(js, "expected at most 2 arguments but found %" Pd "\n",
-                 js->num_arguments());
-    } else {
-      PrintSentinel(js, "objects/expired", "<expired>");
-    }
-    return true;
-  }
-
-  // Lookup the object.
-  Object& obj = Object::Handle(isolate);
-  ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
-  obj = LookupObjectId(isolate, arg, &kind);
-  if (kind == ObjectIdRing::kInvalid) {
-    PrintError(js, "unrecognized object id '%s'", arg);
-    return true;
-  }
-
-  // Print.
-  if (kind == ObjectIdRing::kCollected) {
-    // The object has been collected by the gc.
-    PrintSentinel(js, "objects/collected", "<collected>");
-    return true;
-  } else if (kind == ObjectIdRing::kExpired) {
-    // The object id has expired.
-    PrintSentinel(js, "objects/expired", "<expired>");
-    return true;
-  }
-  obj.PrintJSON(js, false);
-  return true;
-}
-
-
-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());
-  intptr_t 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);
-    }
-  }
-  return true;
-}
-
-
-static bool HandleScripts(Isolate* isolate, JSONStream* js) {
-  if (js->num_arguments() == 1) {
-    // Enumerate all scripts.
-    return HandleScriptsEnumerate(isolate, js);
-  }
-  PrintError(js, "Command too long");
-  return true;
-}
-
-
 static bool HandleIsolateResume(Isolate* isolate, JSONStream* js) {
-  const char* step_option = js->LookupOption("step");
+  const char* step_param = js->LookupParam("step");
   if (isolate->message_handler()->paused_on_start()) {
     isolate->message_handler()->set_pause_on_start(false);
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Success");
     jsobj.AddProperty("id", "");
     return true;
   }
   if (isolate->message_handler()->paused_on_exit()) {
     isolate->message_handler()->set_pause_on_exit(false);
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Success");
     jsobj.AddProperty("id", "");
     return true;
   }
   if (isolate->debugger()->PauseEvent() != NULL) {
-    if (step_option != NULL) {
-      if (strcmp(step_option, "into") == 0) {
+    if (step_param != NULL) {
+      if (strcmp(step_param, "into") == 0) {
         isolate->debugger()->SetSingleStep();
-      } else if (strcmp(step_option, "over") == 0) {
+      } else if (strcmp(step_param, "over") == 0) {
         isolate->debugger()->SetStepOver();
-      } else if (strcmp(step_option, "out") == 0) {
+      } else if (strcmp(step_param, "out") == 0) {
         isolate->debugger()->SetStepOut();
       } else {
-        PrintError(js, "Invalid 'step' option: %s", step_option);
+        PrintInvalidParamError(js, "step");
         return true;
       }
     }
     isolate->Resume();
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Success");
     jsobj.AddProperty("id", "");
     return true;
   }
 
@@ skipping 14 matching lines @@
 static bool HandleIsolatePause(Isolate* isolate, JSONStream* js) {
   // TODO(turnidge): Don't double-interrupt the isolate here.
   isolate->ScheduleInterrupts(Isolate::kApiInterrupt);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Success");
   jsobj.AddProperty("id", "");
   return true;
 }
 
 
-static bool HandleNullCode(uintptr_t pc, JSONStream* js) {
-  // TODO(turnidge): Consider adding/using Object::null_code() for
-  // consistent "type".
-  Object::null_object().PrintJSON(js, false);
-  return true;
-}
-
-
-static bool HandleCode(Isolate* isolate, JSONStream* js) {
-  REQUIRE_COLLECTION_ID("code");
-  uword pc;
-  if (js->num_arguments() > 2) {
-    PrintError(js, "Command too long");
-    return true;
-  }
-  ASSERT(js->num_arguments() == 2);
-  static const char* kCollectedPrefix = "collected-";
-  static intptr_t kCollectedPrefixLen = strlen(kCollectedPrefix);
-  static const char* kNativePrefix = "native-";
-  static intptr_t kNativePrefixLen = strlen(kNativePrefix);
-  static const char* kReusedPrefix = "reused-";
-  static intptr_t kReusedPrefixLen = strlen(kReusedPrefix);
-  const char* command = js->GetArgument(1);
-  if (strncmp(kCollectedPrefix, command, kCollectedPrefixLen) == 0) {
-    if (!GetUnsignedIntegerId(&command[kCollectedPrefixLen], &pc, 16)) {
-      PrintError(js, "Must specify code address: code/%sc0deadd0.",
-                 kCollectedPrefix);
-      return true;
-    }
-    return HandleNullCode(pc, js);
-  }
-  if (strncmp(kNativePrefix, command, kNativePrefixLen) == 0) {
-    if (!GetUnsignedIntegerId(&command[kNativePrefixLen], &pc, 16)) {
-      PrintError(js, "Must specify code address: code/%sc0deadd0.",
-                 kNativePrefix);
-      return true;
-    }
-    // TODO(johnmccutchan): Support native Code.
-    return HandleNullCode(pc, js);
-  }
-  if (strncmp(kReusedPrefix, command, kReusedPrefixLen) == 0) {
-    if (!GetUnsignedIntegerId(&command[kReusedPrefixLen], &pc, 16)) {
-      PrintError(js, "Must specify code address: code/%sc0deadd0.",
-                 kReusedPrefix);
-      return true;
-    }
-    return HandleNullCode(pc, js);
-  }
-  int64_t timestamp = 0;
-  if (!GetCodeId(command, &timestamp, &pc) || (timestamp < 0)) {
-    PrintError(js, "Malformed code id: %s", command);
-    return true;
-  }
-  Code& code = Code::Handle(Code::FindCode(pc, timestamp));
-  if (!code.IsNull()) {
-    code.PrintJSON(js, false);
-    return true;
-  }
-  PrintError(js, "Could not find code with id: %s", command);
-  return true;
-}
-
-
 static bool HandleIsolateGetTagProfile(Isolate* isolate, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
   miniProfile.AddProperty("id", "profile/tag");
   isolate->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
 
 static bool HandleIsolateGetCpuProfile(Isolate* isolate, JSONStream* js) {
   // A full profile includes disassembly of all Dart code objects.
-  // TODO(johnmccutchan): Add sub command to trigger full code dump.
+  // TODO(johnmccutchan): Add option to trigger full code dump.
   bool full_profile = false;
-  const char* tags_option = js->LookupOption("tags");
   Profiler::TagOrder tag_order = Profiler::kUserVM;
-  if (js->HasOption("tags")) {
-    if (js->OptionIs("tags", "None")) {
+  if (js->HasParam("tags")) {
+    if (js->ParamIs("tags", "None")) {
       tag_order = Profiler::kNoTags;
-    } else if (js->OptionIs("tags", "UserVM")) {
+    } else if (js->ParamIs("tags", "UserVM")) {
       tag_order = Profiler::kUserVM;
-    } else if (js->OptionIs("tags", "UserOnly")) {
+    } else if (js->ParamIs("tags", "UserOnly")) {
       tag_order = Profiler::kUser;
-    } else if (js->OptionIs("tags", "VMUser")) {
+    } else if (js->ParamIs("tags", "VMUser")) {
       tag_order = Profiler::kVMUser;
-    } else if (js->OptionIs("tags", "VMOnly")) {
+    } else if (js->ParamIs("tags", "VMOnly")) {
       tag_order = Profiler::kVM;
     } else {
-      PrintError(js, "Invalid tags option value: %s\n", tags_option);
+      PrintInvalidParamError(js, "tags");
       return true;
     }
   }
   Profiler::PrintJSON(isolate, js, full_profile, tag_order);
   return true;
 }
 
 
 static bool HandleIsolateGetAllocationProfile(Isolate* isolate,
                                               JSONStream* js) {
   bool should_reset_accumulator = false;
   bool should_collect = false;
-  if (js->HasOption("reset")) {
-    if (js->OptionIs("reset", "true")) {
+  if (js->HasParam("reset")) {
+    if (js->ParamIs("reset", "true")) {
       should_reset_accumulator = true;
     } else {
-      PrintError(js, "Unrecognized reset option '%s'",
-                 js->LookupOption("reset"));
+      PrintInvalidParamError(js, "reset");
       return true;
     }
   }
-  if (js->HasOption("gc")) {
-    if (js->OptionIs("gc", "full")) {
+  if (js->HasParam("gc")) {
+    if (js->ParamIs("gc", "full")) {
       should_collect = true;
     } else {
-      PrintError(js, "Unrecognized gc option '%s'", js->LookupOption("gc"));
+      PrintInvalidParamError(js, "gc");
       return true;
     }
   }
   if (should_reset_accumulator) {
     isolate->UpdateLastAllocationProfileAccumulatorResetTimestamp();
     isolate->class_table()->ResetAllocationAccumulators();
   }
   if (should_collect) {
     isolate->UpdateLastAllocationProfileGCTimestamp();
     isolate->heap()->CollectAllGarbage();
@@ skipping 52 matching lines @@
     }
     uword obj_begin = RawObject::ToAddr(obj);
     uword obj_end = obj_begin + obj->Size();
     return obj_begin <= addr_ && addr_ < obj_end;
   }
  private:
   uword addr_;
 };
 
 
-static bool HandleAddress(Isolate* isolate, JSONStream* js) {
-  uword addr = 0;
-  if (js->num_arguments() != 2 ||
-      !GetUnsignedIntegerId(js->GetArgument(1), &addr, 16)) {
-    static const uword kExampleAddr = static_cast<uword>(kIntptrMax / 7);
-    PrintError(js, "Must specify address: address/" Px ".", kExampleAddr);
+static bool HandleIsolateGetObjectByAddress(Isolate* isolate, JSONStream* js) {
+  const char* addr_str = js->LookupParam("address");
+  if (addr_str == NULL) {
+    PrintMissingParamError(js, "address");
     return true;
   }
-  bool ref = js->HasOption("ref") && js->OptionIs("ref", "true");
+
+  // Handle heap objects.
+  uword addr = 0;
+  if (!GetUnsignedIntegerId(addr_str, &addr, 16)) {
+    PrintInvalidParamError(js, "address");
+    return true;
+  }
+  bool ref = js->HasParam("ref") && js->ParamIs("ref", "true");
   Object& object = Object::Handle(isolate);
   {
     NoGCScope no_gc;
     ContainsAddressVisitor visitor(isolate, addr);
     object = isolate->heap()->FindObject(&visitor);
   }
   object.PrintJSON(js, ref);
   return true;
 }
 
@@ skipping 13 matching lines @@
 
 
 static bool HandleIsolateRespondWithMalformedObject(Isolate* isolate,
                                                     JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
-static IsolateMessageHandlerEntry isolate_handlers[] = {
-  { "", HandleIsolate },                          // getObject
-  { "address", HandleAddress },                   // to do
-  { "classes", HandleClasses },                   // getObject
-  { "code", HandleCode },                         // getObject
-  { "libraries", HandleLibraries },               // getObject
-  { "objects", HandleObjects },                   // getObject
-  { "scripts", HandleScripts },                   // getObject
-};
-
-
-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 IsolateMessageHandlerEntry& entry = isolate_handlers[i];
-    if (strcmp(command, entry.command) == 0) {
-      return entry.handler;
-    }
-  }
-  if (FLAG_trace_service) {
-    OS::Print("vm-service: No isolate message handler for <%s>.\n", command);
-  }
-  return NULL;
-}
-
-
 static bool HandleIsolateGetObject(Isolate* isolate, JSONStream* js) {
-  const char* id = js->LookupOption("objectId");
+  const char* id = js->LookupParam("objectId");
   if (id == NULL) {
-    // TODO(turnidge): Print the isolate here instead.
-    PrintError(js, "GetObject expects an 'objectId' parameter\n",
-               js->num_arguments());
+    PrintMissingParamError(js, "objectId");
     return true;
   }
 
   // Handle heap objects.
   ObjectIdRing::LookupResult lookup_result;
   const Object& obj =
       Object::Handle(LookupHeapObject(isolate, id, &lookup_result));
   if (obj.raw() != Object::sentinel().raw()) {
     // We found a heap object for this id.  Return it.
     obj.PrintJSON(js, false);
     return true;
   } else if (lookup_result == ObjectIdRing::kCollected) {
     PrintSentinel(js, "objects/collected", "<collected>");
+    return true;
   } else if (lookup_result == ObjectIdRing::kExpired) {
     PrintSentinel(js, "objects/expired", "<expired>");
+    return true;
   }
 
   // Handle non-heap objects.
   SourceBreakpoint* bpt = LookupBreakpoint(isolate, id);
   if (bpt != NULL) {
     bpt->PrintJSON(js);
     return true;
   }
 
   PrintError(js, "Unrecognized object id: %s\n", id);
   return true;
 }
 
 
 static bool HandleIsolateGetClassList(Isolate* isolate, JSONStream* js) {
   ClassTable* table = isolate->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static bool HandleIsolateGetTypeArgumentsList(Isolate* isolate,
                                               JSONStream* js) {
   bool only_with_instantiations = false;
-  if (js->OptionIs("onlyWithInstantiations", "true")) {
+  if (js->ParamIs("onlyWithInstantiations", "true")) {
     only_with_instantiations = true;
   }
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   TypeArguments& type_args = TypeArguments::Handle();
   const intptr_t table_size = table.Length() - 1;
   const intptr_t table_used = Smi::Value(Smi::RawCast(table.At(table_size)));
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "TypeArgumentsList");
   jsobj.AddProperty("canonicalTypeArgumentsTableSize", table_size);
   jsobj.AddProperty("canonicalTypeArgumentsTableUsed", table_used);
   JSONArray members(&jsobj, "typeArguments");
   for (intptr_t i = 0; i < table_size; i++) {
     type_args ^= table.At(i);
     if (!type_args.IsNull()) {
       if (!only_with_instantiations || type_args.HasInstantiations()) {
         members.AddValue(type_args);
       }
     }
   }
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers_new[] = {
   { "getIsolate", HandleIsolate },
   { "getObject", HandleIsolateGetObject },
+  { "getObjectByAddress", HandleIsolateGetObjectByAddress },
   { "getBreakpoints", HandleIsolateGetBreakpoints },
   { "pause", HandleIsolatePause },
   { "resume", HandleIsolateResume },
   { "getStack", HandleIsolateGetStack },
   { "getCpuProfile", HandleIsolateGetCpuProfile },
   { "getTagProfile", HandleIsolateGetTagProfile },
   { "getAllocationProfile", HandleIsolateGetAllocationProfile },
   { "getHeapMap", HandleIsolateGetHeapMap },
   { "addBreakpoint", HandleIsolateAddBreakpoint },
   { "removeBreakpoint", HandleIsolateRemoveBreakpoint },
   { "getCoverage", HandleIsolateGetCoverage },
   { "eval", HandleIsolateEval },
   { "getRetainedSize", HandleIsolateGetRetainedSize },
   { "getRetainingPath", HandleIsolateGetRetainingPath },
   { "getInboundReferences", HandleIsolateGetInboundReferences },
   { "getInstances", HandleIsolateGetInstances },
   { "requestHeapSnapshot", HandleIsolateRequestHeapSnapshot },
   { "getClassList", HandleIsolateGetClassList },
   { "getTypeArgumentsList", HandleIsolateGetTypeArgumentsList },
   { "getIsolateMetricList", HandleIsolateGetMetricList },
   { "getIsolateMetric", HandleIsolateGetMetric },
   { "_echo", HandleIsolateEcho },
   { "_triggerEchoEvent", HandleIsolateTriggerEchoEvent },
   { "_respondWithMalformedJson", HandleIsolateRespondWithMalformedJson },
   { "_respondWithMalformedObject", HandleIsolateRespondWithMalformedObject },
 };
 
 
-static IsolateMessageHandler FindIsolateMessageHandlerNew(const char* command) {
+static IsolateMessageHandler FindIsolateMessageHandler(const char* method) {
   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) {
+    if (strcmp(method, entry.method) == 0) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
-    OS::Print("Service has no isolate message handler for <%s>\n", command);
+    OS::Print("Service has no isolate message handler for <%s>\n", method);
   }
   return NULL;
 }
 
 
-void Service::HandleRootMessageNew(const Array& msg) {
+void Service::HandleRootMessage(const Instance& msg_instance) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(!msg.IsNull());
+  ASSERT(!msg_instance.IsNull());
+  ASSERT(msg_instance.IsArray());
 
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
 
-    const Array& message = Array::Cast(msg);
-    // Message is a list with five entries.
-    ASSERT(message.Length() == 5);
+    const Array& msg = Array::Cast(msg_instance);
+    ASSERT(msg.Length() == 5);
 
     Instance& reply_port = Instance::Handle(isolate);
     String& method = String::Handle(isolate);
     Array& param_keys = Array::Handle(isolate);
     Array& param_values = Array::Handle(isolate);
     reply_port ^= msg.At(1);
     method ^= msg.At(2);
     param_keys ^= msg.At(3);
     param_values ^= msg.At(4);
 
     ASSERT(!method.IsNull());
     ASSERT(!param_keys.IsNull());
     ASSERT(!param_values.IsNull());
     ASSERT(param_keys.Length() == param_values.Length());
 
     if (!reply_port.IsSendPort()) {
       FATAL("SendPort expected.");
     }
 
     RootMessageHandler handler =
-        FindRootMessageHandlerNew(method.ToCString());
+        FindRootMessageHandler(method.ToCString());
     {
       JSONStream js;
-      js.SetupNew(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-                  method, param_keys, param_values);
+      js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
+               method, param_keys, param_values);
       if (handler == NULL) {
         // Check for an embedder handler.
         EmbedderServiceHandler* e_handler =
             FindRootEmbedderHandler(method.ToCString());
         if (e_handler != NULL) {
           EmbedderHandleMessage(e_handler, &js);
         } else {
-          if (FindIsolateMessageHandlerNew(method.ToCString()) != NULL) {
-            PrintError(&js, "%s expects an 'isolate' parameter\n",
-                       method.ToCString());
+          if (FindIsolateMessageHandler(method.ToCString()) != NULL) {
+            PrintMissingParamError(&js, "isolate");
           } else {
             PrintError(&js, "Unrecognized method: %s", method.ToCString());
           }
         }
         js.PostReply();
       } else {
         if (handler(&js)) {
           // Handler returns true if the reply is ready to be posted.
           // TODO(johnmccutchan): Support asynchronous replies.
           js.PostReply();
         }
       }
     }
   }
 }
 
 
-void Service::HandleRootMessage(const Instance& msg) {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(!msg.IsNull());
-  ASSERT(msg.IsArray());
-
-  {
-    StackZone zone(isolate);
-    HANDLESCOPE(isolate);
-
-    const Array& message = Array::Cast(msg);
-    // Message is a list with five entries.
-    ASSERT(message.Length() == 5);
-
-    Object& tmp = Object::Handle(isolate);
-    tmp = message.At(2);
-    if (tmp.IsString()) {
-      return Service::HandleRootMessageNew(message);
-    }
-
-    Instance& reply_port = Instance::Handle(isolate);
-    GrowableObjectArray& path = GrowableObjectArray::Handle(isolate);
-    Array& option_keys = Array::Handle(isolate);
-    Array& option_values = Array::Handle(isolate);
-
-    reply_port ^= message.At(1);
-    path ^= message.At(2);
-    option_keys ^= message.At(3);
-    option_values ^= message.At(4);
-
-    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());
-
-    if (!reply_port.IsSendPort()) {
-      FATAL("SendPort expected.");
-    }
-
-    String& path_segment = String::Handle();
-    if (path.Length() > 0) {
-      path_segment ^= path.At(0);
-    } else {
-      path_segment ^= Symbols::Empty().raw();
-    }
-    ASSERT(!path_segment.IsNull());
-    const char* path_segment_c = path_segment.ToCString();
-
-    RootMessageHandler handler =
-        FindRootMessageHandler(path_segment_c);
-    {
-      JSONStream js;
-      js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-               path, option_keys, option_values);
-      if (handler == NULL) {
-        // Check for an embedder handler.
-        EmbedderServiceHandler* e_handler =
-            FindRootEmbedderHandler(path_segment_c);
-        if (e_handler != NULL) {
-          EmbedderHandleMessage(e_handler, &js);
-        } else {
-          PrintError(&js, "Unrecognized path");
-        }
-        js.PostReply();
-      } else {
-        if (handler(&js)) {
-          // Handler returns true if the reply is ready to be posted.
-          // TODO(johnmccutchan): Support asynchronous replies.
-          js.PostReply();
-        }
-      }
-    }
-  }
-}
-
-
 static bool HandleRootEcho(JSONStream* js) {
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
 class ServiceIsolateVisitor : public IsolateVisitor {
  public:
   explicit ServiceIsolateVisitor(JSONArray* jsarr)
       : jsarr_(jsarr) {
@@ skipping 37 matching lines @@
   // Construct the isolate list.
   {
     JSONArray jsarr(&jsobj, "isolates");
     ServiceIsolateVisitor visitor(&jsarr);
     Isolate::VisitIsolates(&visitor);
   }
   return true;
 }
 
 
-static bool HandleFlags(JSONStream* js) {
-  if (js->num_arguments() == 1) {
-    Flags::PrintJSON(js);
+static bool HandleVMFlagList(JSONStream* js) {
+  Flags::PrintJSON(js);
+  return true;
+}
+
+
+static bool HandleVMSetFlag(JSONStream* js) {
+  const char* flag_name = js->LookupParam("name");
+  if (flag_name == NULL) {
+    PrintMissingParamError(js, "name");
     return true;
-  } else if (js->num_arguments() == 2) {
-    const char* arg = js->GetArgument(1);
-    if (strcmp(arg, "set") == 0) {
-      if (js->num_arguments() > 2) {
-        PrintError(js, "expected at most 2 arguments but found %" Pd "\n",
-                   js->num_arguments());
-      } else {
-        if (js->HasOption("name") && js->HasOption("value")) {
-          JSONObject jsobj(js);
-          const char* flag_name = js->LookupOption("name");
-          const char* flag_value = js->LookupOption("value");
-          const char* error = NULL;
-          if (Flags::SetFlag(flag_name, flag_value, &error)) {
-            jsobj.AddProperty("type", "Success");
-            jsobj.AddProperty("id", "");
-          } else {
-            jsobj.AddProperty("type", "Failure");
-            jsobj.AddProperty("id", "");
-            jsobj.AddProperty("message", error);
-          }
-        } else {
-          PrintError(js, "expected to find 'name' and 'value' options");
-        }
-      }
-    }
+  }
+  const char* flag_value = js->LookupParam("value");
+  if (flag_value == NULL) {
+    PrintMissingParamError(js, "value");
+    return true;
+  }
+  JSONObject jsobj(js);
+  const char* error = NULL;
+  if (Flags::SetFlag(flag_name, flag_value, &error)) {
+    jsobj.AddProperty("type", "Success");
+    jsobj.AddProperty("id", "");
     return true;
   } else {
-    PrintError(js, "Command too long");
+    jsobj.AddProperty("type", "Failure");
+    jsobj.AddProperty("id", "");
+    jsobj.AddProperty("message", error);
     return true;
   }
 }
 
-static RootMessageHandlerEntry root_handlers[] = {
-  { "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 },
+  { "getFlagList", HandleVMFlagList },
+  { "setFlag", HandleVMSetFlag },
   { "getVMMetricList", HandleVMGetMetricList },
   { "getVMMetric", HandleVMGetMetric },
   { "_echo", HandleRootEcho },
 };
 
 
-static RootMessageHandler FindRootMessageHandlerNew(const char* command) {
+static RootMessageHandler FindRootMessageHandler(const char* method) {
   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) {
+    if (strcmp(method, entry.method) == 0) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
-    OS::Print("vm-service: No root message handler for <%s>.\n", command);
+    OS::Print("vm-service: No root message handler for <%s>.\n", method);
   }
   return NULL;
 }
 
 
 void Service::SendEvent(intptr_t eventId, const Object& eventMessage) {
   if (!IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
@@ skipping 66 matching lines @@
   SendEvent(kEventFamilyDebug, message);
 }
 
 
 void Service::EmbedderHandleMessage(EmbedderServiceHandler* handler,
                                     JSONStream* js) {
   ASSERT(handler != NULL);
   Dart_ServiceRequestCallback callback = handler->callback();
   ASSERT(callback != NULL);
   const char* r = NULL;
-  const char* name = js->command();
-  const char** arguments = js->arguments();
-  const char** keys = js->option_keys();
-  const char** values = js->option_values();
-  r = callback(name, arguments, js->num_arguments(), keys, values,
-               js->num_options(), handler->user_data());
+  const char* name = js->method();
+  const char** keys = js->param_keys();
+  const char** values = js->param_values();
+  r = callback(name, keys, values, js->num_params(), handler->user_data());
   ASSERT(r != NULL);
   // TODO(johnmccutchan): Allow for NULL returns?
   TextBuffer* buffer = js->buffer();
   buffer->AddString(r);
   free(const_cast<char*>(r));
 }
 
 
 void Service::RegisterIsolateEmbedderCallback(
     const char* name,
@@ skipping 64 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart