Converted Observatory script-inset & source-inset elements

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 400 matching lines @@
 abstract class ServiceObjectOwner extends ServiceObject {
   /// Creates an empty [ServiceObjectOwner].
   ServiceObjectOwner._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   /// Builds a [ServiceObject] corresponding to the [id] from [map].
   /// The result may come from the cache.  The result will not necessarily
   /// be [loaded].
   ServiceObject getFromMap(ObservableMap map);
 }
 
-abstract class Location  {
+abstract class Location implements M.Location {
   Script get script;
   int get tokenPos;
 }
 
 /// A [SourceLocation] represents a location or range in the source code.
 class SourceLocation extends ServiceObject implements Location,
                                                       M.SourceLocation {
   Script script;
   int tokenPos;
   int endTokenPos;
@@ skipping 30 matching lines @@
     if (endTokenPos == null) {
       return '${script.name}:token(${tokenPos})';
     } else {
       return '${script.name}:tokens(${tokenPos}-${endTokenPos})';
     }
   }
 }
 
 /// An [UnresolvedSourceLocation] represents a location in the source
 // code which has not been precisely mapped to a token position.
-class UnresolvedSourceLocation extends ServiceObject implements Location {
+class UnresolvedSourceLocation extends ServiceObject
+                               implements Location,
+                                          M.UnresolvedSourceLocation {
   Script script;
   String scriptUri;
   int line;
   int column;
   int tokenPos;
 
   Future<int> getLine() async {
     if (tokenPos != null) {
       await script.load();
       return script.tokenToLine(tokenPos);
@@ skipping 1220 matching lines @@
   }
 
   Future<ObjectStore> getObjectStore() {
     return invokeRpcNoUpgrade('_getObjectStore', {}).then((map) {
       ObjectStore objectStore = new ObjectStore._empty(this);
       objectStore._update(map, false);
       return objectStore;
     });
   }
 
-  Future<ServiceObject> _eval(ServiceObject target,
+  Future<ServiceObject> eval(ServiceObject target,
                               String expression) {
     Map params = {
       'targetId': target.id,
       'expression': expression,
     };
     return invokeRpc('evaluate', params);
   }
 
   Future<ServiceObject> evalFrame(int frameIndex,
                                   String expression) {
@@ skipping 478 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 implements M.LibraryRef {
+class Library extends HeapObject implements M.Library {
   @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 immutable => false;
 
   bool isDart(String libraryName) {
@@ skipping 31 matching lines @@
     classes.sort(ServiceObject.LexicalSortName);
     variables.clear();
     variables.addAll(map['variables']);
     variables.sort(ServiceObject.LexicalSortName);
     functions.clear();
     functions.addAll(map['functions']);
     functions.sort(ServiceObject.LexicalSortName);
   }
 
   Future<ServiceObject> evaluate(String expression) {
-    return isolate._eval(this, expression);
+    return isolate.eval(this, expression);
   }
 
   Script get rootScript {
     for (Script script in scripts) {
       if (script.uri == uri) return script;
     }
     return null;
   }
 
   String toString() => "Library($uri)";
@@ skipping 147 matching lines @@
 
   void _addSubclass(Class subclass) {
     if (subclasses.contains(subclass)) {
       return;
     }
     subclasses.add(subclass);
     subclasses.sort(ServiceObject.LexicalSortName);
   }
 
   Future<ServiceObject> evaluate(String expression) {
-    return isolate._eval(this, expression);
+    return isolate.eval(this, expression);
   }
 
   Future<ServiceObject> setTraceAllocations(bool enable) {
     return isolate.invokeRpc('_setTraceClassAllocation', {
         'enable': enable,
         'classId': id,
       });
   }
 
   Future<ServiceObject> getAllocationSamples([String tags = 'None']) {
@@ skipping 303 matching lines @@
     if (isClosure) {
       return closureFunction.qualifiedName;
     }
     if (valueAsString != null) {
       return valueAsString;
     }
     return 'a ${clazz.name}';
   }
 
   Future<ServiceObject> evaluate(String expression) {
-    return isolate._eval(this, expression);
+    return isolate.eval(this, expression);
   }
 
   String toString() => 'Instance($shortName)';
 }
 
 
 class Context extends HeapObject implements M.Context {
   @observable Context parentContext;
   @observable int length;
   @observable Iterable<ContextElement> variables;
@@ skipping 1528 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);
     }
   }
 }