Port metrics to RPC

runtime/vm/service/service.idl

 //
 // TODO(turnidge): Finish writing an idl description of the service protocol.
 //
 
 interface Service {
   // Returns the list of breakpoints for an isolate.
   getBreakpoints(isolateId string) BreakpointList
 
   // Adds a breakpoint at the specified line.
   //
@@ skipping 64 matching lines @@
                        limit int) InboundReferences
 
   getClassList(isolateId string) ClassList
 
   // When <code>onlyWithInstantiations</code> is true, the list only includes
   // type arguments with instantiations. Otherwise, all type arguments are
   // returned.
   getTypeArgumentsList(isolateId string,
                        onlyWithInstantiations bool) TypeArgumentsList
 
+  getIsolateMetricList(isolateId string,
+                       type MetricSelector) MetricList
+
+  getIsolateMetric(isolateId string,
+                   metricId string) Metric
+
+  getVMMetricList() MetricList
+
+  getVMMetric(metricId string) Metric
+
   _echo(isolateId string,
         text string) _EchoResponse
 
   _echoVM(text string) _EchoResponse
 
   // Triggers a ServiceEvent with EventType '_Echo'.
   _triggerEchoEvent(isolateId string,
                     text string) _EchoResponse
 
   // Response is bad JSON.
@@ skipping 218 matching lines @@
 
 
 // TODO(koda): slot can actually be a string, and integer or a
 // FieldRef.  Fix this to be consistent with RetainingPathElement.
 struct InboundReference {
   source InstanceRef
   slot   int
 }
 
 
-struct ClassList {
+struct ClassList extends Response {
   classes []ClassRef
 }
 
 
-struct TypeArgumentsList {
+struct TypeArgumentsList extends Response {
   tableSize int
   tableUsed int
   typeArguments []TypeArgumentsRef
 }
 
 
+struct MetricList extends Response {
+  metrics []Metric
+}
+
+
+struct Metric extends Response {
+  name string
+  description string
+}
+
+
+struct Gauge extends Metric {
+  value double
+  min double
+  max double
+}
+
+
+struct Counter extends Metric {
+  value double
+}
+
+
 // A <code>GCOption</code> is used to indicate which form of garbage
 // collection is requested.
 enum GCOption {
   full
 }
 
 // A <code>StepOption</code> is used to indicate which form of
 // single-stepping is requested.
 enum StepOption {
   into
   over
   out
 }
 
 // A <code>TagSelector</code> is used to indicate which sets of tags
 // should take precedence in a cpu profile.
 enum TagSelector {
   UserVM
   UserOnly
   VMUser
   VMOnly
   None
 }
 
+// A <code>MetricSelector</code> is used to indicate which list of metrics
+// should be retrieved from an isolate.
+enum MetricSelector {
+  Dart,
+  Native,
+}