Add getClassList 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 27 matching lines @@
   // Returns a full cpu profile for an isolate.
   //
   // <code>tagSelector</code> is optional with default 'UserVM'.
   getCpuProfile(isolateId string, tags TagSelector) CpuProfile
 
 
   // Returns a simple tag-based profile for an isolate.
   getTagProfile(isolateId string) TagProfile
 
   // Returns an allocation profile for an isolate.
-  // 
+  //
   // <code>reset</code> is optional and indicates whether allocation
   // accumulators should be reset.
   //
-  // <code>gc</code> is optional and indicates whether a full 
+  // <code>gc</code> is optional and indicates whether a full
   getAllocationProfile(isolateId string,
                        reset bool,
                        gc GCOption) AllocationProfile
 
   // Returns the heap map for an isolate.
   getHeapMap(isolateId string) HeapMap
 
   // Returns how many bytes are retained by some target Class or Instance.
   getRetainedSize(isolateId string, targetId string) InstanceRef
 
   // Returns a path demonstrating why an object is retained in memory.
   //
   // TODO(turnidge): Make limit an int instead of a string.
   getRetainingPath(isolateId string,
                    targetId string,
                    limit int) RetainingPath
 
   // Returns a collection of inbound references to some object.
   //
   // TODO(turnidge): Make limit an int instead of a string.
   getInboundReferences(isolateId string,
                        targetId string,
                        limit int) InboundReferences
+
+  getClassList(isolateId string) ClassList
 }
 
 
 // Every top level response returned by the Service interface extends
 // <code>Response</code>.  This allows the client to distinguish
 // between different kinds of responses by using the <code>type</code>
 // property.
 struct Response {
   // Every response returned by the VM Service has the
   // <code>type</code> property.  This allows the client distinguish
@@ skipping 39 matching lines @@
   id  string
 }
 
 
 // A <code>CodeRef</code> encodes a reference to a <code>Code</code> object.
 struct CodeRef extends ObjectRef {
   placeholder int
 }
 
 
+struct ClassRef extends ObjectRef {
+  placeholder int
+}
+
+
 // A <code>FunctionRef</code> encodes a reference to a <code>Function</code> object.
 struct FunctionRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>FieldRef</code> encodes a reference to a <code>Field</code> object.
 struct FieldRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>InstanceRef</code> encodes a reference to a <code>Instance</code> object.
 struct InstanceRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>ScriptRef</code> encodes a reference to a <code>Script</code> object.
 struct ScriptRef extends ObjectRef {
   placeholder int
 }
 
 
+struct Class extends Object {
+  placeholder int
+}
+
+
 // A <code>Location</code> encodes a location withing a dart script.
 //
 // TODO(turnidge): Should this really be broken out as its own type?
 // If so, we should use it more consistently in the api.  For example,
 // in Frame.
 struct Location {
   script   ScriptRef
   tokenPos int
 }
 
@@ skipping 96 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 {
+  classes []Class

[turnidge, 2015/02/03 17:59:09]

Class -> ClassRef

[Cutch, 2015/02/03 17:59:56]

Done.

+}
+
+
 // 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
 }