Wrapping leaf nodes in non polymer elements

runtime/observatory/lib/src/app/application.dart

 // Copyright (c) 2013, 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 app;
 
-class Notification {
-  Notification.fromEvent(this.event);
-  Notification.fromException(this.exception, this.stacktrace);
-
-  ServiceEvent event;
-  var exception;
-  var stacktrace;
-}
-
 /// The observatory application. Instances of this are created and owned
 /// by the observatory_application custom element.
 class ObservatoryApplication extends Observable {
   static ObservatoryApplication app;
+  final RenderingQueue queue = new RenderingQueue();
+  final TargetRepository targets = new TargetRepository();
+  final NotificationRepository notifications = new NotificationRepository();
   final _pageRegistry = new List<Page>();
   LocationManager _locationManager;
   LocationManager get locationManager => _locationManager;
   @observable Page currentPage;
   VM _vm;
   VM get vm => _vm;
 
-  set vm(VM vm) {
+  _setVM(VM vm) {
     if (_vm == vm) {
       // Do nothing.
       return;
     }
     if (_vm != null) {
       // Disconnect from current VM.
-      notifications.clear();
+      notifications.deleteAll();
       _vm.disconnect();
     }
     if (vm != null) {
       Logger.root.info('Registering new VM callbacks');
 
       vm.onConnect.then((_) {
-        if (vm is WebSocketVM) {
-          targets.add(vm.target);
-        }
         _removeDisconnectEvents();
       });
 
       vm.onDisconnect.then((String reason) {
         if (this.vm != vm) {
           // This disconnect event occured *after* a new VM was installed.
           return;
         }
         notifications.add(
-            new Notification.fromEvent(
-                new ServiceEvent.connectionClosed(reason)));
+            new EventNotification.fromServiceEvent(
+              new ServiceEvent.connectionClosed(reason)));
       });
 
       vm.listenEventStream(VM.kIsolateStream, _onEvent);
       vm.listenEventStream(VM.kDebugStream, _onEvent);
     }
     _vm = vm;
   }
-  final TargetManager targets;
+  //final TargetManager targets;
   @reflectable final ObservatoryApplicationElement rootElement;
 
   TraceViewElement _traceView = null;
 
   @reflectable ServiceObject lastErrorOrException;
-  @observable ObservableList<Notification> notifications =
-      new ObservableList<Notification>();
 
   void _initOnce() {
     assert(app == null);
     app = this;
     _registerPages();
     Analytics.initialize();
     // Visit the current page.
     locationManager._visit();
   }
 
   void removePauseEvents(Isolate isolate) {
-    notifications.removeWhere((notification) {
-        var event = notification.event;
-        return (event != null &&
-                event.isolate == isolate &&
-                event.isPauseEvent);
-      });
+    var remove = notifications.list().where((notification) {
+      var event = notification.event;
+      return notification is M.EventNotification &&
+             notification.event is M.IsolateEvent &&
+             notification.event.isolate == isolate &&
+             M.Event.isPauseEvent(notification.event);
+    }).toList(growable: false);
+    remove.forEach((notification) {
+      notifications.delete(notification);
+    });
   }
 
   void _onEvent(ServiceEvent event) {
     assert(event.kind != ServiceEvent.kNone);
 
     switch(event.kind) {
       case ServiceEvent.kVMUpdate:
       case ServiceEvent.kIsolateStart:
       case ServiceEvent.kIsolateRunnable:
       case ServiceEvent.kIsolateUpdate:
       case ServiceEvent.kBreakpointAdded:
       case ServiceEvent.kBreakpointResolved:
       case ServiceEvent.kBreakpointRemoved:
       case ServiceEvent.kDebuggerSettingsUpdate:
         // Ignore for now.
         break;
 
       case ServiceEvent.kIsolateReload:
-        notifications.add(new Notification.fromEvent(event));
+        notifications.add(new EventNotification.fromServiceEvent(event));
         break;
 
       case ServiceEvent.kIsolateExit:
       case ServiceEvent.kResume:
         removePauseEvents(event.isolate);
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
       case ServiceEvent.kPauseBreakpoint:
       case ServiceEvent.kPauseInterrupted:
       case ServiceEvent.kPauseException:
         removePauseEvents(event.isolate);
-        notifications.add(new Notification.fromEvent(event));
+        notifications.add(new EventNotification.fromServiceEvent(event));
         break;
 
       case ServiceEvent.kInspect:
-        notifications.add(new Notification.fromEvent(event));
+        notifications.add(new EventNotification.fromServiceEvent(event));
         break;
 
       default:
         // Ignore unrecognized events.
         Logger.root.severe('Unrecognized event: $event');
         break;
     }
   }
 
   void _registerPages() {
@@ skipping 71 matching lines @@
 
     // Add tracing support.
     _traceView = new Element.tag('trace-view');
     _traceView.tracer = Tracer.current;
     rootElement.children.add(_traceView);
 
     // Remember page.
     currentPage = page;
   }
 
-  ObservatoryApplication(this.rootElement) :
-      targets = new TargetManager() {
+  ObservatoryApplication(this.rootElement) {
     _locationManager = new LocationManager(this);
-    vm = new WebSocketVM(targets.defaultTarget);
+    targets.onChange.listen((e) {
+      if (targets.current == null) return _setVM(null);
+      if ((_vm as WebSocketVM)?.target != targets.current) {
+        _setVM(new WebSocketVM(targets.current));
+      }
+    });
+    _setVM(new WebSocketVM(targets.current));
     _initOnce();
   }
 
   void _removeDisconnectEvents() {
-    notifications.removeWhere((notification) {
-        var event = notification.event;
-        return (event != null &&
-                event.kind == ServiceEvent.kConnectionClosed);
-      });
+    var remove = notifications.list().where((notification) {
+      return notification is EventNotification &&
+             notification.event is M.ConnectionClosedEvent;
+    }).toList(growable: false);
+    remove.forEach((notification){
+      notifications.delete(notification);
+    });
   }
 
   loadCrashDump(Map crashDump) {
-    this.vm = new FakeVM(crashDump['result']);
+    _setVM(new FakeVM(crashDump['result']));
     app.locationManager.go('#/vm');
   }
 
   void handleException(e, st) {
     if (e is ServerRpcException) {
       if (e.code == ServerRpcException.kFeatureDisabled) return;
       if (e.code == ServerRpcException.kIsolateMustBePaused) return;
       if (e.code == ServerRpcException.kCannotAddBreakpoint) return;
       Logger.root.fine('Dropping exception: ${e}\n${st}');
     }
 
     // TODO(turnidge): Report this failure via analytics.
     Logger.root.warning('Caught exception: ${e}\n${st}');
-    notifications.add(new Notification.fromException(e, st));
+    notifications.add(new ExceptionNotification(e, stacktrace: st));
   }
 
   // This map keeps track of which curly-blocks have been expanded by the user.
   Map<String,bool> expansions = {};
 }