Introduced support for external services registration in the ServiceProtocol

runtime/observatory/lib/src/service/object.dart

 // Copyright (c) 2014, 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.
 
 part of service;
 
 // Some value smaller than the object ring, so requesting a large array
 // doesn't result in an expired ref because the elements lapped it in the
 // object ring.
 const int kDefaultFieldLimit = 100;
@@ skipping 647 matching lines @@
   // Used for verbose logging.
   bool verbose = false;
 
   // TODO(johnmccutchan): Ensure that isolates do not end up in _cache.
   Map<String, ServiceObject> _cache = new Map<String, ServiceObject>();
   final Map<String, Isolate> _isolateCache = <String, Isolate>{};
 
   // The list of live isolates, ordered by isolate start time.
   final List<Isolate> isolates = <Isolate>[];
 
+  final List<Service> services = <Service>[];
+
   String version = 'unknown';
   String hostCPU;
   String targetCPU;
   int architectureBits;
   bool assertsEnabled = false;
   bool typeChecksEnabled = false;
   int nativeZoneMemoryUsage = 0;
   int pid = 0;
   int heapAllocatedMemoryUsage = 0;
   int heapAllocationCount = 0;
@@ skipping 170 matching lines @@
     });
   }
 
   void _dispatchEventToIsolate(ServiceEvent event) {
     var isolate = event.isolate;
     if (isolate != null) {
       isolate._onEvent(event);
     }
   }
 
+  void _updateService(ServiceEvent event) {
+    switch (event.kind) {
+      case ServiceEvent.kServiceRegistered:
+        services.add(new Service(event.alias, event.method, event.service));
+        break;
+      case ServiceEvent.kServiceUnregistered:
+        services.removeWhere((s) => s.method == event.method);
+        break;
+    }
+  }
+
   Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) async {
     if (!loaded) {
       // The vm service relies on these events to keep the VM and
       // Isolate types up to date.
       try {
         await listenEventStream(kVMStream, _dispatchEventToIsolate);
         await listenEventStream(kIsolateStream, _dispatchEventToIsolate);
         await listenEventStream(kDebugStream, _dispatchEventToIsolate);
         await listenEventStream(_kGraphStream, _dispatchEventToIsolate);
+        await listenEventStream(kServiceStream, _updateService);
       } on FakeVMRpcException catch (_) {
         // ignore FakeVMRpcExceptions here.
       } on NetworkRpcException catch (_) {
         // ignore network errors here.
       }
     }
     return await invokeRpcNoUpgrade('getVM', {});
   }
 
   Future setName(String newName) {
@@ skipping 27 matching lines @@
 
   // Well-known stream ids.
   static const kVMStream = 'VM';
   static const kIsolateStream = 'Isolate';
   static const kTimelineStream = 'Timeline';
   static const kDebugStream = 'Debug';
   static const kGCStream = 'GC';
   static const kStdoutStream = 'Stdout';
   static const kStderrStream = 'Stderr';
   static const _kGraphStream = '_Graph';
+  static const kServiceStream = '_Service';
 
   /// Returns a single-subscription Stream object for a VM event stream.
   Future<Stream> getEventStream(String streamId) async {
     var eventStream = _eventStreams.putIfAbsent(
         streamId,
         () => new _EventStreamState(
             this, streamId, () => _eventStreams.remove(streamId)));
     Stream stream = await eventStream.addStream();
     return stream;
   }
@@ skipping 1194 matching lines @@
   static const kBreakpointAdded = 'BreakpointAdded';
   static const kBreakpointResolved = 'BreakpointResolved';
   static const kBreakpointRemoved = 'BreakpointRemoved';
   static const kGraph = '_Graph';
   static const kGC = 'GC';
   static const kInspect = 'Inspect';
   static const kDebuggerSettingsUpdate = '_DebuggerSettingsUpdate';
   static const kConnectionClosed = 'ConnectionClosed';
   static const kLogging = '_Logging';
   static const kExtension = 'Extension';
-  static const kEditor = '_Editor';
+  static const kServiceRegistered = 'ServiceRegistered';
+  static const kServiceUnregistered = 'ServiceUnregistered';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
     kind = kConnectionClosed;
   }
 
   String kind;
   DateTime timestamp;
   List<M.Breakpoint> pauseBreakpoints;
@@ skipping 11 matching lines @@
   String exceptions;
   String bytesAsString;
   Map logRecord;
   String extensionKind;
   Map extensionData;
   List timelineEvents;
   String spawnToken;
   String spawnError;
   String editor;
   ServiceObject object;
+  String method;
+  String service;
+  String alias;
 
   int chunkIndex, chunkCount, nodeCount;
 
   bool get isPauseEvent {
     return (kind == kPauseStart ||
         kind == kPauseExit ||
         kind == kPauseBreakpoint ||
         kind == kPauseInterrupted ||
         kind == kPauseException ||
         kind == kPausePostRequest ||
@@ skipping 76 matching lines @@
     }
     if (map['spawnError'] != null) {
       spawnError = map['spawnError'];
     }
     if (map['editor'] != null) {
       editor = map['editor'];
     }
     if (map['object'] != null) {
       object = map['object'];
     }
+    if (map['service'] != null) {
+      service = map['service'];
+    }
+    if (map['method'] != null) {
+      method = map['method'];
+    }
+    if (map['alias'] != null) {
+      alias = map['alias'];
+    }
   }
 
   String toString() {
     var ownerName = owner.id != null ? owner.id.toString() : owner.name;
     if (data == null) {
       return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "time=${timestamp})";
     } else {
       return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "data.lengthInBytes=${data.lengthInBytes}, time=${timestamp})";
@@ skipping 2391 matching lines @@
     var v = list[i];
     if ((v is Map) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is List) {
       _upgradeList(v, owner);
     } else if (v is Map) {
       _upgradeMap(v, owner);
     }
   }
 }
+
+class Service implements M.Service {
+  final String alias;
+  final String method;
+  final String service;
+
+  Service(this.alias, this.method, this.service) {
+    assert(this.alias != null);
+    assert(this.method != null);
+    assert(this.service != null);
+  }
+}