Add a VM page to the observatory.

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 "vm/compiler.h"
 #include "vm/coverage.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
+#include "vm/version.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_service, false, "Trace VM service requests.");
 
 struct ResourcesEntry {
   const char* path_;
   const char* resource_;
   int length_;
@@ skipping 590 matching lines @@
           // TODO(johnmccutchan): Support asynchronous replies.
           js.PostReply();
         }
       }
     }
   }
 }
 
 
 static bool HandleIsolate(Isolate* isolate, JSONStream* js) {
-  isolate->PrintToJSONStream(js);
+  isolate->PrintToJSONStream(js, false);
   return true;
 }
 
 
 static bool HandleStackTrace(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() > 1) {
     PrintError(js, "Command too long");
     return true;
   }
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
@@ skipping 659 matching lines @@
       PrintError(js, "Command too long");
       return true;
     }
   } else {
     PrintError(js, "Unrecognized subcommand '%s'", js->GetArgument(1));
     return true;
   }
 }
 
 
-static bool HandleCpu(Isolate* isolate, JSONStream* js) {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "CPU");
-  jsobj.AddProperty("targetCPU", CPU::Id());
-  jsobj.AddProperty("hostCPU", HostCPUFeatures::hardware());
-  return true;
-}
-
-
 static bool HandleNullCode(uintptr_t pc, JSONStream* js) {
   // TODO(turnidge): Consider adding/using Object::null_code() for
   // consistent "type".
   Object::null_object().PrintToJSONStream(js, false);
   return true;
 }
 
 
 static bool HandleCode(Isolate* isolate, JSONStream* js) {
   REQUIRE_COLLECTION_ID("code");
@@ skipping 88 matching lines @@
   if (js->num_arguments() != 1) {
     PrintError(js, "Command too long");
     return true;
   }
   isolate->class_table()->AllocationProfilePrintToJSONStream(js);
   return true;
 }
 
 
 static bool HandleResume(Isolate* isolate, JSONStream* js) {
-  // TODO(johnmccutchan): What do I respond with??
   if (isolate->message_handler()->pause_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()->pause_on_exit()) {
     isolate->message_handler()->set_pause_on_exit(false);
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "Success");
+    jsobj.AddProperty("id", "");
     return true;
   }
+
+  PrintError(js, "VM was not paused");
   return true;
 }
 
 
 static bool HandleHeapMap(Isolate* isolate, JSONStream* js) {
   isolate->heap()->PrintHeapMapToJSONStream(js);
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers[] = {
   { "_echo", HandleIsolateEcho },
   { "", HandleIsolate },
   { "allocationprofile", HandleAllocationProfile },
   { "classes", HandleClasses },
   { "code", HandleCode },
   { "coverage", HandleCoverage },
-  { "cpu", HandleCpu },
   { "debug", HandleDebug },
   { "heapmap", HandleHeapMap },
   { "libraries", HandleLibraries },
   { "objects", HandleObjects },
   { "profile", HandleProfile },
   { "resume", HandleResume },
   { "scripts", HandleScripts },
   { "stacktrace", HandleStackTrace },
 };
 
@@ skipping 81 matching lines @@
 
 
 static bool HandleRootEcho(JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "message");
   PrintArgumentsAndOptions(jsobj, js);
   return true;
 }
 
 
-static bool HandleCpu(JSONStream* js) {
+class ServiceIsolateVisitor : public IsolateVisitor {
+ public:
+  explicit ServiceIsolateVisitor(JSONArray* jsarr)
+      : jsarr_(jsarr) {
+  }
+
+  virtual ~ServiceIsolateVisitor() {}
+
+  void VisitIsolate(Isolate* isolate) {
+    if (isolate != Dart::vm_isolate() && !Service::IsServiceIsolate(isolate)) {
+      jsarr_->AddValue(isolate);
+    }
+  }
+
+ private:
+  JSONArray* jsarr_;
+};
+
+
+static bool HandleVM(JSONStream* js) {
   JSONObject jsobj(js);
-  jsobj.AddProperty("type", "CPU");
+  jsobj.AddProperty("type", "VM");
+  jsobj.AddProperty("id", "vm");
   jsobj.AddProperty("architecture", CPU::Id());
+  jsobj.AddProperty("version", Version::String());
+
+  int64_t start_time_micros = Dart::vm_isolate()->start_time();
+  int64_t uptime_micros = (OS::GetCurrentTimeMicros() - start_time_micros);
+  double seconds = (static_cast<double>(uptime_micros) /
+                    static_cast<double>(kMicrosecondsPerSecond));
+  jsobj.AddProperty("uptime", seconds);
+
+  // Construct the isolate list.
+  {
+    JSONArray jsarr(&jsobj, "isolates");
+    ServiceIsolateVisitor visitor(&jsarr);
+    Isolate::VisitIsolates(&visitor);
+  }
   return true;
 }
 
 
 static RootMessageHandlerEntry root_handlers[] = {
   { "_echo", HandleRootEcho },
-  { "cpu", HandleCpu },
+  { "vm", HandleVM },
 };
 
 
 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;
@@ skipping 95 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart