Support root-level json rpc 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 "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 823 matching lines @@
 // posting the reply (this can be used for asynchronous delegation of
 // the response handling).
 typedef bool (*RootMessageHandler)(JSONStream* stream);
 
 struct RootMessageHandlerEntry {
   const char* command;
   RootMessageHandler handler;
 };
 
 static RootMessageHandler FindRootMessageHandler(const char* command);
+static RootMessageHandler FindRootMessageHandlerNew(const char* command);
 
 
 static void PrintArgumentsAndOptions(const JSONObject& obj, JSONStream* js) {
   JSONObject jsobj(&obj, "request");
   {
     JSONArray jsarr(&jsobj, "arguments");
     for (intptr_t i = 0; i < js->num_arguments(); i++) {
       jsarr.AddValue(js->GetArgument(i));
     }
   }
@@ skipping 595 matching lines @@
       return Object::sentinel().raw();
     }
     return type.raw();
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
+static RawObject* LookupHeapObjectCode(Isolate* isolate,
+                                       char** parts, int num_parts) {
+  if (num_parts != 2) {
+    return Object::sentinel().raw();
+  }
+  uword pc;
+  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* id = parts[1];
+  if (strncmp(kCollectedPrefix, id, kCollectedPrefixLen) == 0) {
+    if (!GetUnsignedIntegerId(&id[kCollectedPrefixLen], &pc, 16)) {
+      return Object::sentinel().raw();
+    }
+    // TODO(turnidge): Return "collected" instead.
+    return Object::null();
+  }
+  if (strncmp(kNativePrefix, id, kNativePrefixLen) == 0) {
+    if (!GetUnsignedIntegerId(&id[kNativePrefixLen], &pc, 16)) {
+      return Object::sentinel().raw();
+    }
+    // TODO(johnmccutchan): Support native Code.
+    return Object::null();
+  }
+  if (strncmp(kReusedPrefix, id, kReusedPrefixLen) == 0) {
+    if (!GetUnsignedIntegerId(&id[kReusedPrefixLen], &pc, 16)) {
+      return Object::sentinel().raw();
+    }
+    // TODO(turnidge): Return "expired" instead.
+    return Object::null();
+  }
+  int64_t timestamp = 0;
+  if (!GetCodeId(id, &timestamp, &pc) || (timestamp < 0)) {
+    return Object::sentinel().raw();
+  }
+  Code& code = Code::Handle(Code::FindCode(pc, timestamp));
+  if (!code.IsNull()) {
+    return code.raw();
+  }
+
+  // Not found.
+  return Object::sentinel().raw();
+}
+
+
 static RawObject* LookupHeapObject(Isolate* isolate,
                                    const char* id_original,
                                    ObjectIdRing::LookupResult* result) {
   char* id = isolate->current_zone()->MakeCopyOfString(id_original);
 
   // Parse the id by splitting at each '/'.
   const int MAX_PARTS = 8;
   char* parts[MAX_PARTS];
   int num_parts = 0;
   int i = 0;
@@ skipping 28 matching lines @@
         *result = lookup_result;
       }
       return Object::sentinel().raw();
     }
     return obj.raw();
 
   } else if (strcmp(parts[0], "libraries") == 0) {
     return LookupHeapObjectLibraries(isolate, parts, num_parts);
   } else if (strcmp(parts[0], "classes") == 0) {
     return LookupHeapObjectClasses(isolate, parts, num_parts);
+  } else if (strcmp(parts[0], "code") == 0) {
+    return LookupHeapObjectCode(isolate, parts, num_parts);
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
 static void PrintSentinel(JSONStream* js,
                           const char* id,
                           const char* preview) {
@@ skipping 1385 matching lines @@
     }
   }
   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("id");
+  const char* id = js->LookupOption("objectId");
   if (id == NULL) {
     // TODO(turnidge): Print the isolate here instead.
-    PrintError(js, "GetObject expects an 'id' parameter\n",
+    PrintError(js, "GetObject expects an 'objectId' parameter\n",
                js->num_arguments());
     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.
@@ skipping 19 matching lines @@
 
 static bool HandleIsolateGetClassList(Isolate* isolate, JSONStream* js) {
   ClassTable* table = isolate->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers_new[] = {
+  { "getIsolate", HandleIsolate },
   { "getObject", HandleIsolateGetObject },
   { "getBreakpoints", HandleIsolateGetBreakpoints },
   { "pause", HandleIsolatePause },
   { "resume", HandleIsolateResume },
   { "getStack", HandleIsolateGetStack },
   { "getCpuProfile", HandleIsolateGetCpuProfile },
   { "getTagProfile", HandleIsolateGetTagProfile },
   { "getAllocationProfile", HandleIsolateGetAllocationProfile },
   { "getHeapMap", HandleIsolateGetHeapMap },
   { "addBreakpoint", HandleIsolateAddBreakpoint },
@@ skipping 18 matching lines @@
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
     OS::Print("Service has no isolate message handler for <%s>\n", command);
   }
   return NULL;
 }
 
 
+void Service::HandleRootMessageNew(const Array& msg) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(!msg.IsNull());
+
+  {
+    StackZone zone(isolate);
+    HANDLESCOPE(isolate);
+
+    const Array& message = Array::Cast(msg);
+    // Message is a list with five entries.
+    ASSERT(message.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());
+    {
+      JSONStream js;
+      js.SetupNew(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 {
+          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();
+        }
+      }
+    }
+  }
+}
+
+
 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);
 
@@ skipping 156 matching lines @@
       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 },
+};
+
+
+static RootMessageHandler FindRootMessageHandlerNew(const char* command) {
+  intptr_t num_message_handlers = sizeof(root_handlers_new) /
+                                  sizeof(root_handlers_new[0]);
+  for (intptr_t i = 0; i < num_message_handlers; i++) {
+    const RootMessageHandlerEntry& entry = root_handlers_new[i];
+    if (strcmp(command, entry.command) == 0) {
+      return entry.handler;
+    }
+  }
+  if (FLAG_trace_service) {
+    OS::Print("vm-service: No root message handler for <%s>.\n", command);
+  }
+  return NULL;
+}
+
+
 void Service::SendEvent(intptr_t eventId, const Object& eventMessage) {
   if (!IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
 
   // Construct a list of the form [eventId, eventMessage].
   const Array& list = Array::Handle(Array::New(2));
@@ skipping 151 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart