Converted Observatory nav-notify element

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;
 
 /// Helper function for canceling a Future<StreamSubscription>.
 Future cancelFutureSubscription(
     Future<StreamSubscription> subscriptionFuture) async {
   if (subscriptionFuture != null) {
     var subscription = await subscriptionFuture;
     return subscription.cancel();
   } else {
     return null;
   }
 }
 
 /// An RpcException represents an exceptional event that happened
 /// while invoking an rpc.
-abstract class RpcException implements Exception {
+abstract class RpcException implements Exception, M.BasicException {
   RpcException(this.message);
 
   String message;
 }
 
 /// A ServerRpcException represents an error returned by the VM.
-class ServerRpcException extends RpcException {
+class ServerRpcException extends RpcException implements M.RequestException {
   /// A list of well-known server error codes.
   static const kParseError     = -32700;
   static const kInvalidRequest = -32600;
   static const kMethodNotFound = -32601;
   static const kInvalidParams  = -32602;
   static const kInternalError  = -32603;
   static const kFeatureDisabled         = 100;
   static const kCannotAddBreakpoint     = 102;
   static const kStreamAlreadySubscribed = 103;
   static const kStreamNotSubscribed     = 104;
@@ skipping 20 matching lines @@
   ServerRpcException.fromMap(Map errorMap) : super(_getMessage(errorMap)) {
     code = errorMap['code'];
     data = errorMap['data'];
   }
 
   String toString() => 'ServerRpcException(${message})';
 }
 
 /// A NetworkRpcException is used to indicate that an rpc has
 /// been canceled due to network error.
-class NetworkRpcException extends RpcException {
+class NetworkRpcException extends RpcException
+                          implements M.ConnectionException {
   NetworkRpcException(String message) : super(message);
 
   String toString() => 'NetworkRpcException(${message})';
 }
 
 class MalformedResponseRpcException extends RpcException {
   MalformedResponseRpcException(String message, this.response)
       : super(message);
 
   Map response;
@@ skipping 333 matching lines @@
   /// be [loaded].
   ServiceObject getFromMap(ObservableMap map);
 }
 
 abstract class Location  {
   Script get script;
   int get tokenPos;
 }
 
 /// A [SourceLocation] represents a location or range in the source code.
-class SourceLocation extends ServiceObject implements Location {
+class SourceLocation extends ServiceObject implements Location,
+                                                          M.SourceLocation {
   Script script;
   int tokenPos;
   int endTokenPos;
 
   Future<int> getLine() async {
     await script.load();
     return script.tokenToLine(tokenPos);
   }
 
   Future<int> getColumn() async {
@@ skipping 158 matching lines @@
   }
 
   void addEvent(ServiceEvent event) {
     for (var controller in _controllers) {
       controller.add(event);
     }
   }
 }
 
 /// State for a VM being inspected.
-abstract class VM extends ServiceObjectOwner {
+abstract class VM extends ServiceObjectOwner implements M.VM {
   @reflectable VM get vm => this;
   @reflectable Isolate get isolate => null;
 
   // TODO(turnidge): The connection should not be stored in the VM object.
   bool get isDisconnected;
 
   // 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 ObservableMap<String,Isolate> _isolateCache =
       new ObservableMap<String,Isolate>();
 
   // The list of live isolates, ordered by isolate start time.
   final ObservableList<Isolate> isolates = new ObservableList<Isolate>();
 
   @observable String version = 'unknown';
+  @observable String hostCPU;
   @observable String targetCPU;
   @observable int architectureBits;
   @observable bool assertsEnabled = false;
   @observable bool typeChecksEnabled = false;
   @observable int pid = 0;
   @observable bool profileVM = false;
   @observable DateTime startTime;
   @observable DateTime refreshTime;
   @observable Duration get upTime {
     if (startTime == null) {
@@ skipping 254 matching lines @@
     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'];
+    hostCPU = map['hostCPU'];
     targetCPU = map['targetCPU'];
     architectureBits = map['architectureBits'];
     int startTimeMillis = map['startTime'];
     startTime = new DateTime.fromMillisecondsSinceEpoch(startTimeMillis);
     refreshTime = new DateTime.now();
     notifyPropertyChange(#upTime, 0, 1);
     pid = map['pid'];
     profileVM = map['_profilerMode'] == 'VM';
     assertsEnabled = map['_assertsEnabled'];
     typeChecksEnabled = map['_typeChecksEnabled'];
@@ skipping 201 matching lines @@
           print("${obj.runtimeType} should be a HeapObject");
         }
         return obj;
       }));
     }
     return result;
   }
 }
 
 /// State for a running isolate.
-class Isolate extends ServiceObjectOwner {
+class Isolate extends ServiceObjectOwner implements M.Isolate {
   static const kLoggingStream = '_Logging';
   static const kExtensionStream = 'Extension';
 
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
   @observable int number;
   @observable int originNumber;
   @observable DateTime startTime;
   @observable Duration get upTime {
     if (startTime == null) {
@@ skipping 896 matching lines @@
     if (data == null) {
       return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "time=${timestamp})";
     } else {
       return "ServiceEvent(owner='${ownerName}', kind='${kind}', "
           "data.lengthInBytes=${data.lengthInBytes}, time=${timestamp})";
     }
   }
 }
 
-class Breakpoint extends ServiceObject {
+class Breakpoint extends ServiceObject implements M.Breakpoint {
   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.
   bool get canCache => true;
   bool get immutable => false;
 
   // A unique integer identifier for this breakpoint.
   @observable int number;
 
@@ skipping 75 matching lines @@
 
   LibraryDependency._(this.isImport, this.isDeferred, this.prefix, this.target);
 
   static _fromMap(map) => new LibraryDependency._(map["isImport"],
                                                   map["isDeferred"],
                                                   map["prefix"],
                                                   map["target"]);
 }
 
 
-class Library extends HeapObject {
+class Library extends HeapObject implements M.LibraryRef {
   @observable String uri;
   @reflectable final dependencies = new ObservableList<LibraryDependency>();
   @reflectable final scripts = new ObservableList<Script>();
   @reflectable final classes = new ObservableList<Class>();
   @reflectable final variables = new ObservableList<Field>();
   @reflectable final functions = new ObservableList<ServiceFunction>();
 
   bool get canCache => true;
   bool get immutable => false;
 
@@ skipping 81 matching lines @@
   void update(List stats) {
     accumulated.instances = stats[ACCUMULATED];
     accumulated.bytes = stats[ACCUMULATED_SIZE];
     current.instances = stats[LIVE_AFTER_GC] + stats[ALLOCATED_SINCE_GC];
     current.bytes = stats[LIVE_AFTER_GC_SIZE] + stats[ALLOCATED_SINCE_GC_SIZE];
   }
 
   bool get empty => accumulated.empty && current.empty;
 }
 
-class Class extends HeapObject {
+class Class extends HeapObject implements M.ClassRef {
   @observable Library library;
 
   @observable bool isAbstract;
   @observable bool isConst;
   @observable bool isFinalized;
   @observable bool isPatch;
   @observable bool isImplemented;
 
   @observable SourceLocation location;
 
@@ skipping 674 matching lines @@
 }
 
 /// The location of a local variable reference in a script.
 class LocalVarLocation {
   final int line;
   final int column;
   final int endColumn;
   LocalVarLocation(this.line, this.column, this.endColumn);
 }
 
-class Script extends HeapObject {
+class Script extends HeapObject implements M.Script {
   final lines = new ObservableList<ScriptLine>();
   @observable String uri;
   @observable String kind;
   @observable DateTime loadTime;
   @observable int firstTokenPos;
   @observable int lastTokenPos;
   @observable int lineOffset;
   @observable int columnOffset;
   @observable Library library;
 
+  String source;
+
   bool get immutable => true;
 
   String _shortUri;
 
   Script._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ScriptLine getLine(int line) {
     assert(_loaded);
     assert(line >= 1);
     return lines[line - lineOffset - 1];
@@ skipping 81 matching lines @@
     vmName = uri;
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     int loadTimeMillis = map['_loadTime'];
     loadTime = new DateTime.fromMillisecondsSinceEpoch(loadTimeMillis);
     lineOffset = map['lineOffset'];
     columnOffset = map['columnOffset'];
     _parseTokenPosTable(map['tokenPosTable']);
+    source = map['source'];
     _processSource(map['source']);
     library = map['library'];
   }
 
   void _parseTokenPosTable(List<List<int>> table) {
     if (table == null) {
       return;
     }
     _tokenToLine.clear();
     _tokenToCol.clear();
@@ skipping 937 matching lines @@
   void _onPoll(_) {
     // Reload metrics and add a sample to each.
     for (var metric in metrics) {
       metric.reload().then((m) {
         m.addSample(new MetricSample(m.value));
       });
     }
   }
 }
 
-class Frame extends ServiceObject {
+class Frame extends ServiceObject implements M.Frame {
   @observable int index;
   @observable ServiceFunction function;
   @observable SourceLocation location;
   @observable Code code;
   @observable List<ServiceMap> variables = new ObservableList<ServiceMap>();
 
   Frame._empty(ServiceObject owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     assert(!mapIsRef);
@@ skipping 114 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);
     }
   }
 }