Improve displaying overlays.

pkg/analysis_server/lib/src/get_handler.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.
 
 library analysis_server.src.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 101 matching lines @@
    */
   static const String CONTEXT_QUERY_PARAM = 'context';
 
   /**
    * Query parameter used to represent the descriptor to search for, when
    * accessing [CACHE_STATE_PATH].
    */
   static const String DESCRIPTOR_QUERY_PARAM = 'descriptor';
 
   /**
-   * Query parameter used to represent the index in the [_overlayContents].
-   */
-  static const String ID_PARAM = 'id';
-
-  /**
    * Query parameter used to represent the name of elements to search for, when
    * accessing [INDEX_ELEMENT_BY_NAME].
    */
   static const String INDEX_ELEMENT_NAME = 'name';
 
   /**
+   * Query parameter used to represent the path of an overlayed file.
+   */
+  static const String PATH_PARAM = 'path';
+
+  /**
    * Query parameter used to represent the source to search for, when accessing
    * [CACHE_ENTRY_PATH].
    */
   static const String SOURCE_QUERY_PARAM = 'entry';
 
   /**
    * Query parameter used to represent the cache state to search for, when
    * accessing [CACHE_STATE_PATH].
    */
   static const String STATE_QUERY_PARAM = 'state';
 
   static final ContentType _htmlContent =
       new ContentType("text", "html", charset: "utf-8");
 
   /**
    * The socket server whose status is to be reported on.
    */
   SocketServer _server;
 
   /**
    * Buffer containing strings printed by the analysis server.
    */
   List<String> _printBuffer;
 
   /**
    * Contents of overlay files.
    */
-  final Map<int, String> _overlayContents = <int, String>{};
+  final Map<String, String> _overlayContents = <String, String>{};
 
   /**
    * Initialize a newly created handler for GET requests.
    */
   GetHandler(this._server, this._printBuffer);
 
   /**
    * Return the active [CompletionDomainHandler]
    * or `null` if either analysis server is not running
    * or there is no completion domain handler.
@@ skipping 537 matching lines @@
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
       return _returnFailure(request, 'Invalid context: $contextFilter');
     }
 
     List<String> priorityNames;
     List<String> explicitNames = <String>[];
     List<String> implicitNames = <String>[];
     Map<String, String> links = new HashMap<String, String>();
     List<CaughtException> exceptions = <CaughtException>[];
-    Map<String, int> overlayMap = new HashMap<String, int>();
     AnalysisContextImpl context = analysisServer.folderMap[folder];
     priorityNames =
         context.prioritySources.map((Source source) => source.fullName).toList();
     context.visitCacheItems(
         (Source source, SourceEntry sourceEntry, DataDescriptor rowDesc,
             CacheState state) {
       String sourceName = source.fullName;
       if (!links.containsKey(sourceName)) {
         CaughtException exception = sourceEntry.exception;
         if (exception != null) {
           exceptions.add(exception);
         }
         String link = makeLink(CACHE_ENTRY_PATH, {
           CONTEXT_QUERY_PARAM: folder.path,
           SOURCE_QUERY_PARAM: source.uri.toString()
         }, sourceName, exception != null);
         if (sourceEntry.explicitlyAdded) {
           explicitNames.add(sourceName);
         } else {
           implicitNames.add(sourceName);
         }
         links[sourceName] = link;
       }
     });
-    _overlayContents.clear();
-    int count = 0;
-    context.visitContentCache((Source source, int stamp, String contents) {
-      count++;
-      overlayMap[source.fullName] = count;
-      _overlayContents[count] = contents;
-    });
     explicitNames.sort();
     implicitNames.sort();
 
+    _overlayContents.clear();
+    context.visitContentCache((Source source, int stamp, String contents) {
+      _overlayContents[source.fullName] = contents;
+    });
+
     void _writeFiles(StringBuffer buffer, String title, List<String> fileNames)
         {
       buffer.write('<h3>$title</h3>');
       if (fileNames == null || fileNames.isEmpty) {
         buffer.write('<p>None</p>');
       } else {
         buffer.write('<table style="width: 100%">');
         for (String fileName in fileNames) {
           buffer.write('<tr><td>');
           buffer.write(links[fileName]);
           buffer.write('</td><td>');
-          if (overlayMap.containsKey(fileName)) {
+          if (_overlayContents.containsKey(fileName)) {
             buffer.write(makeLink(OVERLAY_PATH, {
-              ID_PARAM: overlayMap[fileName].toString()
+              PATH_PARAM: fileName
             }, 'overlay'));
           }
           buffer.write('</td></tr>');
         }
         buffer.write('</table>');
       }
     }
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(
@@ skipping 149 matching lines @@
           });
           buffer.write('</table>');
         });
       });
     } else {
       return _returnFailure(request, 'LocalIndex expected, but $index found.');
     }
   }
 
   void _returnOverlayContents(HttpRequest request) {
-    String idString = request.requestedUri.queryParameters[ID_PARAM];
-    if (idString == null) {
-      return _returnFailure(request, 'Query parameter $ID_PARAM required');
+    String path = request.requestedUri.queryParameters[PATH_PARAM];
+    if (path == null) {
+      return _returnFailure(request, 'Query parameter $PATH_PARAM required');
     }
-    int id = int.parse(idString);
-    String contents = _overlayContents[id];
+    String contents = _overlayContents[path];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(
           buffer,
           'Analysis Server - Overlay',
           [],
           (StringBuffer buffer) {
         buffer.write('<pre>${HTML_ESCAPE.convert(contents)}</pre>');
       });
     });
   }
 
   /**
    * Return a response displaying overlays information.
    */
   void _returnOverlaysInfo(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(
           buffer,
           'Analysis Server - Overlays',
           [],
           (StringBuffer buffer) {
         buffer.write('<table border="1">');
-        int count = 0;
         _overlayContents.clear();
-        analysisServer.folderMap.forEach((_, AnalysisContextImpl context) {
-          context.visitContentCache(
-              (Source source, int stamp, String contents) {
-            count++;
-            buffer.write('<tr>');
-            String linkRef = '$OVERLAY_PATH?id=$count';
-            String linkText = HTML_ESCAPE.convert(source.toString());
-            buffer.write('<td><a href="$linkRef">$linkText</a></td>');
-            buffer.write(
-                '<td>${new DateTime.fromMillisecondsSinceEpoch(stamp)}</td>');
-            buffer.write('</tr>');
-            _overlayContents[count] = contents;
-          });
+        ContentCache overlayState = analysisServer.overlayState;
+        overlayState.accept((Source source, int stamp, String contents) {
+          String fileName = source.fullName;
+          buffer.write('<tr>');
+          String link = makeLink(OVERLAY_PATH, {
+            PATH_PARAM: fileName
+          }, fileName);
+          DateTime time = new DateTime.fromMillisecondsSinceEpoch(stamp);
+          _writeRow(buffer, [link, time]);
+          _overlayContents[fileName] = contents;
         });
+        int count = _overlayContents.length;
         buffer.write('<tr><td colspan="2">Total: $count entries.</td></tr>');
         buffer.write('</table>');
       });
     });
   }
 
   /**
    * Return a response indicating the status of the analysis server.
    */
   void _returnServerStatus(HttpRequest request) {
@@ skipping 20 matching lines @@
         buffer.write('<p>');
         buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion data'));
         buffer.write('</p>');
         buffer.write('<p>');
         buffer.write(
             makeLink(COMMUNICATION_PERFORMANCE_PATH, {}, 'Performance'));
         buffer.write('</p>');
         buffer.write('<p>');
         buffer.write(makeLink(STATUS_PATH, {}, 'Server status'));
         buffer.write('</p>');
+        buffer.write('<p>');
+        buffer.write(makeLink(OVERLAYS_PATH, {}, 'File overlays'));
+        buffer.write('</p>');
       });
     });
   }
 
   /**
    * Return a two digit decimal representation of the given non-negative integer
    * [value].
    */
   String _twoDigit(int value) {
     if (value < 10) {
@@ skipping 614 matching lines @@
    * 'error'.
    */
   static String makeLink(String path, Map<String, String> params,
       String innerHtml, [bool hasError = false]) {
     Uri uri = new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
     return '<a href="$href"$classAttribute>$innerHtml</a>';
   }
 }