Port metrics to RPC

runtime/vm/service.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/service.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 2400 matching lines @@
   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());
   return metrics_cls.raw();
 }
 
 
-static bool HandleIsolateMetricsList(Isolate* isolate, JSONStream* js) {
+static bool HandleNativeMetricsList(Isolate* isolate, JSONStream* js) {
   JSONObject obj(js);
   obj.AddProperty("type", "MetricList");
-  obj.AddProperty("id", "metrics/vm");
   {
-    JSONArray members(&obj, "members");
+    JSONArray metrics(&obj, "metrics");
     Metric* current = isolate->metrics_list_head();
     while (current != NULL) {
-      members.AddValue(current);
+      metrics.AddValue(current);
       current = current->next();
     }
   }
   return true;
 }
 
 
-static bool HandleIsolateMetric(Isolate* isolate,
+static bool HandleNativeMetric(Isolate* isolate,
                                 JSONStream* js,
                                 const char* id) {
   Metric* current = isolate->metrics_list_head();
   while (current != NULL) {
     const char* name = current->name();
     ASSERT(name != NULL);
     if (strcmp(name, id) == 0) {
       current->PrintJSON(js);
       return true;
     }
     current = current->next();
   }
-  PrintError(js, "Metric %s not found\n", id);
+  PrintError(js, "Native Metric %s not found\n", id);
   return true;
 }
 
 
-static bool HandleMetricsList(Isolate* isolate, JSONStream* js) {
+static bool HandleDartMetricsList(Isolate* isolate, JSONStream* js) {
   const Class& metrics_cls = Class::Handle(isolate, GetMetricsClass(isolate));
   const String& print_metrics_name =
       String::Handle(String::New("_printMetrics"));
   ASSERT(!print_metrics_name.IsNull());
   const Function& print_metrics = Function::Handle(
       isolate,
       metrics_cls.LookupStaticFunctionAllowPrivate(print_metrics_name));
   ASSERT(!print_metrics.IsNull());
   const Array& args = Object::empty_array();
   const Object& result =
       Object::Handle(isolate, DartEntry::InvokeFunction(print_metrics, args));
   ASSERT(!result.IsNull());
   ASSERT(result.IsString());
   TextBuffer* buffer = js->buffer();
   buffer->AddString(String::Cast(result).ToCString());
   return true;
 }
 
 
-static bool HandleMetric(Isolate* isolate, JSONStream* js, const char* id) {
+static bool HandleDartMetric(Isolate* isolate, JSONStream* js, const char* id) {
   const Class& metrics_cls = Class::Handle(isolate, GetMetricsClass(isolate));
   const String& print_metric_name =
       String::Handle(String::New("_printMetric"));
   ASSERT(!print_metric_name.IsNull());
   const Function& print_metric = Function::Handle(
       isolate,
       metrics_cls.LookupStaticFunctionAllowPrivate(print_metric_name));
   ASSERT(!print_metric.IsNull());
   const String& arg0 = String::Handle(String::New(id));
   ASSERT(!arg0.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   ASSERT(!args.IsNull());
   args.SetAt(0, arg0);
   const Object& result =
       Object::Handle(isolate, DartEntry::InvokeFunction(print_metric, args));
   if (!result.IsNull()) {
     ASSERT(result.IsString());
     TextBuffer* buffer = js->buffer();
     buffer->AddString(String::Cast(result).ToCString());
     return true;
   }
-  PrintError(js, "Metric %s not found\n", id);
+  PrintError(js, "Dart Metric %s not found\n", id);
   return true;
 }
 
 
-static bool HandleMetrics(Isolate* isolate, JSONStream* js) {
-  if (js->num_arguments() == 1) {
-    return HandleMetricsList(isolate, js);
-  }
-  ASSERT(js->num_arguments() > 1);
-  const char* arg = js->GetArgument(1);
-  if (strcmp(arg, "vm") == 0) {
-    if (js->num_arguments() == 2) {
-      return HandleIsolateMetricsList(isolate, js);
+static bool HandleIsolateGetMetricList(Isolate* isolate, JSONStream* js) {
+  bool native_metrics = false;
+  if (js->HasOption("type")) {
+    if (js->OptionIs("type", "Native")) {
+      native_metrics = true;
+    } else if (js->OptionIs("type", "Dart")) {
+      native_metrics = false;
     } else {
-      if (js->num_arguments() > 3) {
-        PrintError(js, "Command too long");
-        return true;
-      }
-      return HandleIsolateMetric(isolate, js, js->GetArgument(2));
+      PrintError(js, "Invalid 'type' option value: %s\n",
+                 js->LookupOption("type"));
+      return true;
     }
-  }
-  if (js->num_arguments() > 2) {
-    PrintError(js, "Command too long");
+  } else {
+    PrintError(js, "Expected 'type' option.");
     return true;
   }
-  return HandleMetric(isolate, js, arg);
+  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");
+  if (metric_id == NULL) {
+    PrintError(js, "Expected 'metricId' option.");
+    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");
+  if (metric_id == NULL) {
+    PrintError(js, "Expected 'metricId' option.");
+  }
+  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.
@@ skipping 374 matching lines @@
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers[] = {
   { "", HandleIsolate },                          // getObject
   { "address", HandleAddress },                   // to do
   { "classes", HandleClasses },                   // getObject
   { "code", HandleCode },                         // getObject
   { "libraries", HandleLibraries },               // getObject
-  { "metrics", HandleMetrics },                   // to do - complex?
   { "objects", HandleObjects },                   // getObject
   { "scripts", HandleScripts },                   // getObject
 };
 
 
 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];
@@ skipping 95 matching lines @@
   { "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) {
   intptr_t num_message_handlers = sizeof(isolate_handlers_new) /
                                   sizeof(isolate_handlers_new[0]);
@@ skipping 261 matching lines @@
   }
   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 },
+  { "getVMMetricList", HandleVMGetMetricList },
+  { "getVMMetric", HandleVMGetMetric },
   { "_echo", HandleRootEcho },
 };
 
 
 static RootMessageHandler FindRootMessageHandlerNew(const char* command) {
   intptr_t num_message_handlers = sizeof(root_handlers_new) /
                                   sizeof(root_handlers_new[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const RootMessageHandlerEntry& entry = root_handlers_new[i];
     if (strcmp(command, entry.command) == 0) {
@@ skipping 171 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart