Fixes for html report

lib/src/server/dependency_graph.dart

 // Copyright (c) 2015, 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.
 
 /// Tracks the shape of the import/export graph and dependencies between files.
 library dev_compiler.src.dependency_graph;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' show parseDirectives;
@@ skipping 14 matching lines @@
 import 'package:analyzer/src/generated/source.dart' show Source, SourceKind;
 import 'package:html/dom.dart' show Document, Node, Element;
 import 'package:html/parser.dart' as html;
 import 'package:logging/logging.dart' show Logger, Level;
 import 'package:path/path.dart' as path;
 
 import '../compiler.dart' show defaultRuntimeFiles;
 import '../info.dart';
 import '../options.dart';
 import '../report.dart';
+import '../report/html_reporter.dart';
 
 /// Holds references to all source nodes in the import graph. This is mainly
 /// used as a level of indirection to ensure that each source has a canonical
 /// representation.
 class SourceGraph {
   /// All nodes in the source graph. Used to get a canonical representation for
   /// any node.
   final Map<Uri, SourceNode> nodes = {};
 
   /// Resources included by default on any application.
@@ skipping 94 matching lines @@
     int newStamp = _source.exists() ? _source.modificationStamp : -1;
     if (newStamp > _lastStamp || newStamp == -1 && _lastStamp != -1) {
       // If the timestamp changed, read the file from disk and cache it.
       // We don't want the source text to change during compilation.
       saveUpdatedContents();
       _lastStamp = newStamp;
       needsRebuild = true;
     }
   }
 
+  void clearSummary() {}
+
   void saveUpdatedContents() {}
 
   String toString() {
     var simpleUri = uri.scheme == 'file' ? path.relative(uri.path) : "$uri";
     return '[$runtimeType: $simpleUri]';
   }
 }
 
 /// A node representing an entry HTML source file.
 class HtmlSourceNode extends SourceNode {
@@ skipping 18 matching lines @@
 
   /// Tracks resource files referenced from HTML nodes, e.g.
   /// `<link rel=stylesheet href=...>` and `<img src=...>`
   final htmlResourceNodes = new HashMap<Element, ResourceSourceNode>();
 
   HtmlSourceNode(SourceGraph graph, Uri uri, Source source)
       : runtimeDeps = graph.runtimeDeps,
         super(graph, uri, source);
 
   @override
+  void clearSummary() {
+    var reporter = graph._reporter;
+    if (reporter is HtmlReporter) {
+      reporter.reporter.clearHtml(uri);
+    } else if (reporter is SummaryReporter) {
+      reporter.clearHtml(uri);
+    }
+  }
+
+  @override
   void update() {
     super.update();
     if (needsRebuild) {
-      var reporter = graph._reporter;
-      if (reporter is SummaryReporter) {
-        reporter.clearHtml(uri);
-      }
       document = html.parse(contents, generateSpans: true);
       var newScripts = new Set<DartSourceNode>();
       var tags = document.querySelectorAll('script[type="application/dart"]');
       for (var script in tags) {
         var src = script.attributes['src'];
         if (src == null) {
           _reportError(
               graph,
               'inlined script tags not supported at this time '
               '(see https://github.com/dart-lang/dart-dev-compiler/issues/54).',
@@ skipping 80 matching lines @@
   // once, but how else can we ensure a consistent view across a given
   // compile? One different from dev_compiler vs analyzer is that our
   // messages later in the compiler need the original source text to print
   // spans. We also read source text ourselves to parse directives.
   // But we could discard it after that point.
   void saveUpdatedContents() {
     graph._context.setContents(_source, _source.contents.data);
   }
 
   @override
+  void clearSummary() {
+    var reporter = graph._reporter;
+    if (reporter is HtmlReporter) {
+      reporter.reporter.clearLibrary(uri);
+    } else if (reporter is SummaryReporter) {
+      reporter.clearLibrary(uri);
+    }
+  }
+
+  @override
   void update() {
     super.update();
 
     if (needsRebuild) {
-      var reporter = graph._reporter;
-      if (reporter is SummaryReporter) {
-        reporter.clearLibrary(uri);
-      }
-
       // If the defining compilation-unit changed, the structure might have
       // changed.
       var unit = parseDirectives(contents, name: _source.fullName);
       var newImports = new Set<DartSourceNode>();
       var newExports = new Set<DartSourceNode>();
       var newParts = new Set<DartSourceNode>();
       for (var d in unit.directives) {
         // Nothing to do for parts.
         if (d is PartOfDirective) return;
         if (d is LibraryDirective) continue;
@@ skipping 192 matching lines @@
     var deps = includeParts ? node.allDeps : node.depsWithoutParts;
     deps.forEach(helper);
     action(node);
   }
   helper(start);
 }
 
 bool _same(Set a, Set b) => a.length == b.length && a.containsAll(b);
 
 final _log = new Logger('dev_compiler.dependency_graph');