We can now name the current VM using the service protocol.

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;
 
 /// Helper function for canceling a Future<StreamSubscription>.
 Future cancelFutureSubscription(
     Future<StreamSubscription> subscriptionFuture) async {
   if (subscriptionFuture != null) {
@@ skipping 622 matching lines @@
   final ObservableList<Isolate> isolates = new ObservableList<Isolate>();
 
   @observable String version = 'unknown';
   @observable String targetCPU;
   @observable int architectureBits;
   @observable bool assertsEnabled = false;
   @observable bool typeChecksEnabled = false;
   @observable int pid = 0;
   @observable DateTime startTime;
   @observable DateTime refreshTime;
-  @observable Duration get upTime =>
-      (new DateTime.now().difference(startTime));
+  @observable Duration get upTime {
+    if (startTime == null) {
+      return null;
+    }
+    return (new DateTime.now().difference(startTime));
+  }
+  @observable String get nameAndAddress => '${name}@${target.networkAddress}';
 
   VM() : super._empty(null) {
-    name = 'vm';
-    vmName = 'vm';
-    _cache['vm'] = this;
-    update(toObservable({'id':'vm', 'type':'@VM'}));
+    update(toObservable({'name':'vm', 'type':'@VM'}));
   }
 
   void postServiceEvent(String streamId, Map response, ByteData data) {
     var map = toObservable(response);
     assert(!map.containsKey('_data'));
     if (data != null) {
       map['_data'] = data;
     }
     if (map['type'] != 'Event') {
       Logger.root.severe(
@@ skipping 65 matching lines @@
     toRemove.forEach((id) => _isolateCache.remove(id));
     _buildIsolateList();
   }
 
   static final String _isolateIdPrefix = 'isolates/';
 
   ServiceObject getFromMap(ObservableMap map) {
     if (map == null) {
       return null;
     }
+    var type = _stripRef(map['type']);
+    if (type == 'VM') {
+      // Update this VM object.
+      update(map);
+      return this;
+    }
+
+    assert(type == 'Isolate');
     String id = map['id'];
     if (!id.startsWith(_isolateIdPrefix)) {
       // Currently the VM only supports upgrading Isolate ServiceObjects.
       throw new UnimplementedError();
     }
 
     // Check cache.
     var isolate = _isolateCache[id];
     if (isolate == null) {
       // Add new isolate to the cache.
@@ skipping 63 matching lines @@
   }
 
   Future restart() {
     return invokeRpc('_restartVM', {});
   }
 
   Future<ObservableMap> _fetchDirect() async {
     if (!loaded) {
       // The vm service relies on these events to keep the VM and
       // Isolate types up to date.
+      await listenEventStream(kVMStream, _dispatchEventToIsolate);
       await listenEventStream(kIsolateStream, _dispatchEventToIsolate);
       await listenEventStream(kDebugStream, _dispatchEventToIsolate);
       await listenEventStream(_kGraphStream, _dispatchEventToIsolate);
     }
     return await invokeRpcNoUpgrade('getVM', {});
   }
 
+  Future setName(String newName) {
+    return invokeRpc('setVMName', { 'name': newName });
+  }
+
   Future<ServiceObject> getFlagList() {
     return invokeRpc('getFlagList', {});
   }
 
   Future<ServiceObject> _streamListen(String streamId) {
     Map params = {
       'streamId': streamId,
     };
     return invokeRpc('streamListen', params);
   }
 
   Future<ServiceObject> _streamCancel(String streamId) {
     Map params = {
       'streamId': streamId,
     };
     return invokeRpc('streamCancel', params);
   }
 
   // A map from stream id to event stream state.
   Map<String,_EventStreamState> _eventStreams = {};
 
   // Well-known stream ids.
+  static const kVMStream = 'VM';
   static const kIsolateStream = 'Isolate';
   static const kDebugStream = 'Debug';
   static const kGCStream = 'GC';
   static const kStdoutStream = 'Stdout';
   static const kStderrStream = 'Stderr';
   static const _kGraphStream = '_Graph';
 
   /// Returns a single-subscription Stream object for a VM event stream.
   Future<Stream> getEventStream(String streamId) async {
     var eventStream = _eventStreams.putIfAbsent(
@@ skipping 10 matching lines @@
   }
 
   /// Force the VM to disconnect.
   void disconnect();
   /// Completes when the VM first connects.
   Future get onConnect;
   /// Completes when the VM disconnects or there was an error connecting.
   Future get onDisconnect;
 
   void _update(ObservableMap map, bool mapIsRef) {
+    name = map['name'];
+    notifyPropertyChange(#nameAndAddress, 0, 1);
+    vmName = map.containsKey('_vmName') ? map['_vmName'] : name;
     if (mapIsRef) {
       return;
     }
     // Note that upgrading the collection creates any isolates in the
     // isolate list which are new.
     _upgradeCollection(map, vm);
 
     _loaded = true;
     version = map['version'];
     targetCPU = map['targetCPU'];
@@ skipping 216 matching lines @@
 }
 
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner with Coverage {
   static const kLoggingStream = '_Logging';
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
   @observable int number;
   @observable int originNumber;
   @observable DateTime startTime;
-  @observable Duration get upTime =>
-      (new DateTime.now().difference(startTime));
+  @observable Duration get upTime {
+    if (startTime == null) {
+      return null;
+    }
+    return (new DateTime.now().difference(startTime));
+  }
 
   @observable ObservableMap counters = new ObservableMap();
 
   void _updateRunState() {
     topFrame = (pauseEvent != null ? pauseEvent.topFrame : null);
     paused = (pauseEvent != null &&
               pauseEvent.kind != ServiceEvent.kResume);
     running = (!paused && topFrame != null);
     idle = (!paused && topFrame == null);
     notifyPropertyChange(#topFrame, 0, 1);
@@ skipping 208 matching lines @@
     return _snapshotFetch.stream;
   }
 
   void updateHeapsFromMap(ObservableMap map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
   void _update(ObservableMap map, bool mapIsRef) {
     name = map['name'];
-    vmName = map['name'];
+    vmName = map.containsKey('_vmName') ? map['_vmName'] : name;

[Cutch, 2015/10/08 20:05:27]

Why are we looking for the _vmName in the Isolate's update?

[turnidge, 2015/10/08 22:15:26]

Resolved offline.  This is not "the name of the vm" it is the "the vm's internal
name for this object"

     number = int.parse(map['number'], onError:(_) => null);
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
 
     _upgradeCollection(map, isolate);
     originNumber = int.parse(map['_originNumber'], onError:(_) => null);
     rootLibrary = map['rootLib'];
@@ skipping 123 matching lines @@
 
       case ServiceEvent.kGraph:
         _loadHeapSnapshot(event);
         break;
 
       case ServiceEvent.kGC:
         // Ignore GC events for now.
         break;
 
       default:
-        // Log unrecognized events.
-        Logger.root.severe('Unrecognized event: $event');
+        // Log unexpected events.
+        Logger.root.severe('Unexpected event: $event');
         break;
     }
   }
 
   Future<ServiceObject> addBreakpoint(
       Script script, int line, [int col]) async {
     // TODO(turnidge): Pass line as an int instead of a string.
     try {
       Map params = {
         'scriptId': script.id,
@@ skipping 329 matching lines @@
     if (level.value == value) {
       return level;
     }
   }
   return new Level('$value', value);
 }
 
 /// A [ServiceEvent] is an asynchronous event notification from the vm.
 class ServiceEvent extends ServiceObject {
   /// The possible 'kind' values.
+  static const kVMUpdate               = 'VMUpdate';
   static const kIsolateStart           = 'IsolateStart';
   static const kIsolateRunnable        = 'IsolateRunnable';
   static const kIsolateExit            = 'IsolateExit';
   static const kIsolateUpdate          = 'IsolateUpdate';
   static const kPauseStart             = 'PauseStart';
   static const kPauseExit              = 'PauseExit';
   static const kPauseBreakpoint        = 'PauseBreakpoint';
   static const kPauseInterrupted       = 'PauseInterrupted';
   static const kPauseException         = 'PauseException';
   static const kResume                 = 'Resume';
@@ skipping 97 matching lines @@
     }
     if (map['logRecord'] != null) {
       logRecord = map['logRecord'];
       logRecord['time'] =
           new DateTime.fromMillisecondsSinceEpoch(logRecord['time']);
       logRecord['level'] = _findLogLevel(logRecord['level']);
     }
   }
 
   String toString() {
+    var ownerName = owner.id != null ? owner.id.toString() : owner.name;
     if (data == null) {
-      return "ServiceEvent(owner='${owner.id}', kind='${kind}', "
+      return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "time=${timestamp})";
     } else {
-      return "ServiceEvent(owner='${owner.id}', kind='${kind}', "
+      return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "data.lengthInBytes=${data.lengthInBytes}, time=${timestamp})";
     }
   }
 }
 
 class Breakpoint extends ServiceObject {
   Breakpoint._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   // TODO(turnidge): Add state to track if a breakpoint has been
   // removed from the program.  Remove from the cache when deleted.
@@ skipping 1970 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }