Redo LocationManager to use HTML5 History API

runtime/bin/vmservice/client/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;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
@@ skipping 11 matching lines @@
   @reflectable String get id => _id;
   String _id;
 
   /// The service type of this object.
   @reflectable String get serviceType => _serviceType;
   String _serviceType;
 
   /// The complete service url of this object.
   @reflectable String get link => _owner.relativeLink(_id);
 
-  /// The complete service url of this object with a '#/' prefix.
-  // TODO(turnidge): Figure out why using a getter here messes up polymer.
-  @reflectable String get hashLink => '#/${link}';
-  @reflectable set hashLink(var o) { /* silence polymer */ }
-
   /// Has this object been fully loaded?
   bool get loaded => _loaded;
   bool _loaded = false;
   // TODO(turnidge): Make loaded observable and get rid of loading
   // from Isolate.
 
   /// Is this object cacheable?  That is, is it impossible for the [id]
   /// of this object to change?
   bool get canCache => false;
 
@@ skipping 13 matching lines @@
       return null;
     }
     if (!_isServiceMap(map)) {
       Logger.root.severe('Malformed service object: $map');
     }
     assert(_isServiceMap(map));
     var type = _stripRef(map['type']);
     var obj = null;
     assert(type != 'VM');
     switch (type) {
+      case 'Class':
+        obj = new Class._empty(owner);
+        break;
       case 'Code':
         obj = new Code._empty(owner);
         break;
       case 'Error':
         obj = new DartError._empty(owner);
         break;
       case 'Isolate':
         obj = new Isolate._empty(owner);
         break;
       case 'Library':
@@ skipping 165 matching lines @@
     return reload().then((result) {
         if (result is! VM) {
           return null;
         }
         assert(result == this);
         return _isolateCache[isolateId];
       });
   }
 
   Future<ServiceObject> get(String id) {
-    var parts = id.split('#');
-    assert(parts.length >= 1);
-    // We should never see more than two hashes.
-    assert(parts.length <= 2);
-    // The ID does not include anything after the # (or the # itself).
-    id = parts[0];
-    // I'm serious.
-    assert(!id.contains('#'));
+    assert(id.startsWith('/') == false);
     // Isolates are handled specially, since they can cache sub-objects.
     if (id.startsWith(_isolatesPrefix)) {
       String isolateId = _parseIsolateId(id);
       String objectId = _parseObjectId(id);
       return _getIsolate(isolateId).then((isolate) {
           if (isolate == null) {
             // The isolate does not exist.  Return the VM object instead.
             //
             // TODO(turnidge): Generate a service error?
             return this;
           }
           if (objectId == null) {
             return isolate.reload();
           } else {
             return isolate.get(objectId);
           }
         });
     }
 
     var obj = _cache[id];
     if (obj != null) {
       return obj.reload();
     }
+
     // Cache miss.  Get the object from the vm directly.
     return getAsMap(id).then((ObservableMap map) {
-        var obj = new ServiceObject._fromMap(this, map);
-        if (obj.canCache) {
-          _cache.putIfAbsent(id, () => obj);
-        }
-        return obj;
-      });
+      var obj = new ServiceObject._fromMap(this, map);
+      if (obj.canCache) {
+        _cache.putIfAbsent(id, () => obj);
+      }
+      return obj;
+    });
   }
 
   dynamic _reviver(dynamic key, dynamic value) {
     return value;
   }
 
   ObservableMap _parseJSON(String response) {
     var map;
     try {
       var decoder = new JsonDecoder(_reviver);
@@ skipping 187 matching lines @@
     }
   }
 }
 
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner {
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
   @observable ObservableMap counters = new ObservableMap();
 
-  String get link => _id;
-  String get hashLink => '#/$_id';
+  String get link => '/${_id}';
 
   @observable ServiceMap pauseEvent = null;
   bool get _isPaused => pauseEvent != null;
 
   @observable bool running = false;
   @observable bool idle = false;
   @observable bool loading = true;
   @observable bool ioEnabled = false;
 
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   final TagProfile tagProfile = new TagProfile(20);
 
   Isolate._empty(ServiceObjectOwner owner) : super._empty(owner) {
     assert(owner is VM);
   }
 
   /// Creates a link to [id] relative to [this].
-  @reflectable String relativeLink(String id) => '${this.id}/$id';
-  /// Creates a relative link to [id] with a '#/' prefix.
-  @reflectable String relativeHashLink(String id) => '#/${relativeLink(id)}';
+  @reflectable String relativeLink(String id) => '/${this.id}/$id';
 
   static const TAG_ROOT_ID = 'code/tag-0';
 
   /// Returns the Code object for the root tag.
   Code tagRoot() {
     // TODO(turnidge): Use get() here instead?
     return _cache[TAG_ROOT_ID];
   }
 
   void processProfile(ServiceMap profile) {
@@ skipping 45 matching lines @@
   }
 
   void _processScriptCoverage(ObservableMap scriptCoverage) {
     // Because the coverage data was upgraded into a ServiceObject,
     // the script can be directly accessed.
     Script script = scriptCoverage['script'];
     assert(_cache.containsValue(script));
     script._processHits(scriptCoverage['hits']);
   }
 
+  /// Fetches and builds the class hierarchy for this isolate. Returns the
+  /// Object class object.
+  Future<Class> getClassHierarchy() {
+    return get('classes').then(_loadClasses).then(_buildClassHierarchy);
+  }
+
+  /// Given the class list, loads each class.
+  Future<List<Class>> _loadClasses(ServiceMap classList) {
+    assert(classList.serviceType == 'ClassList');
+    var futureClasses = [];
+    for (var cls in classList['members']) {
+      // Skip over non-class classes.
+      if (cls is Class) {
+        futureClasses.add(cls.load());
+      }
+    }
+    return Future.wait(futureClasses);
+  }
+
+  /// Builds the class hierarchy and returns the Object class.
+  Future<Class> _buildClassHierarchy(List<Class> classes) {
+    rootClasses.clear();
+    objectClass = null;
+    for (var cls in classes) {
+      if (cls.superClass == null) {
+        rootClasses.add(cls);
+      }
+      if ((cls.vmName == 'Object') && (cls.isPatch == false)) {
+        objectClass = cls;
+      }
+    }
+    assert(objectClass != null);
+    return new Future.value(objectClass);
+  }
+
   ServiceObject getFromMap(ObservableMap map) {
     if (map == null) {
       return null;
     }
     String id = map['id'];
     var obj = _cache[id];
     if (obj != null) {
       return obj;
     }
     // Build the object from the map directly.
@@ skipping 14 matching lines @@
     // Cache miss.  Get the object from the vm directly.
     return vm.getAsMap(relativeLink(id)).then((ObservableMap map) {
         var obj = new ServiceObject._fromMap(this, map);
         if (obj.canCache) {
           _cache.putIfAbsent(id, () => obj);
         }
         return obj;
       });
   }
 
+  @observable Class objectClass;
+  @observable final rootClasses = new ObservableList<Class>();
+
   @observable Library rootLib;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
   @observable ObservableMap topFrame;
 
   @observable String name;
   @observable String vmName;
   @observable String mainPort;
   @observable Map entry;
 
@@ skipping 267 matching lines @@
     response = map['response'];
     name = 'ServiceException $kind';
     vmName = name;
   }
 }
 
 class Library extends ServiceObject {
   @observable String url;
   @reflectable final imports = new ObservableList<Library>();
   @reflectable final scripts = new ObservableList<Script>();
-  @reflectable final classes = new ObservableList<ServiceMap>();
+  @reflectable final classes = new ObservableList<Class>();
   @reflectable final variables = new ObservableList<ServiceMap>();
   @reflectable final functions = new ObservableList<ServiceMap>();
 
   bool get canCache => true;
   bool get immutable => false;
 
   Library._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     url = map['url'];
@@ skipping 18 matching lines @@
     scripts.addAll(map['scripts']);
     classes.clear();
     classes.addAll(map['classes']);
     variables.clear();
     variables.addAll(map['variables']);
     functions.clear();
     functions.addAll(map['functions']);
   }
 }
 
+class Class extends ServiceObject {
+  @observable Library library;
+  @observable Script script;
+  @observable Class superClass;
+
+  @observable bool isAbstract;
+  @observable bool isConst;
+  @observable bool isFinalized;
+  @observable bool isPatch;
+  @observable bool isImplemented;
+
+  @observable int tokenPos;
+
+  @observable ServiceMap error;
+
+  @reflectable final children = new ObservableList<Class>();
+  @reflectable final subClasses = new ObservableList<Class>();
+  @reflectable final fields = new ObservableList<ServiceMap>();
+  @reflectable final functions = new ObservableList<ServiceMap>();
+  @reflectable final interfaces = new ObservableList<Class>();
+
+  bool get canCache => true;
+  bool get immutable => false;
+
+  Class._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  String toString() {
+    return 'Service Class: $vmName';
+  }
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    name = map['user_name'];
+    vmName = map['name'];
+
+    if (mapIsRef) {
+      return;
+    }
+
+    // We are fully loaded.
+    _loaded = true;
+
+    // Extract full properties.
+    _upgradeCollection(map, isolate);
+
+    // Some builtin classes aren't associated with a library.
+    if (map['library'] is Library) {
+      library = map['library'];
+    } else {
+      library = null;
+    }
+
+    script = map['script'];
+
+    isAbstract = map['abstract'];
+    isConst = map['const'];
+    isFinalized = map['finalized'];
+    isPatch = map['patch'];
+    isImplemented = map['implemented'];
+
+    tokenPos = map['tokenPos'];
+
+    subClasses.clear();
+    subClasses.addAll(map['subclasses']);
+
+    fields.clear();
+    fields.addAll(map['fields']);
+
+    functions.clear();
+    functions.addAll(map['functions']);
+
+    superClass = map['super'];
+    if (superClass != null) {
+      superClass._addToChildren(this);
+    }
+    error = map['error'];
+  }
+
+  void _addToChildren(Class cls) {
+    if (children.contains(cls)) {
+      return;
+    }
+    children.add(cls);
+  }
+}
+
 class ScriptLine {
   @reflectable final int line;
   @reflectable final String text;
   ScriptLine(this.line, this.text);
 }
 
 class Script extends ServiceObject {
   @reflectable final lines = new ObservableList<ScriptLine>();
   @reflectable final hits = new ObservableMap<int, int>();
   @observable String kind;
@@ skipping 668 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);
     }
   }
 }