performance measurement mods:

pkg/analysis_server/benchmark/integration/input_converter.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.
 
 library input.transformer;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 44 matching lines @@
   /**
    * The prefix used to determine if a request parameter is a file path.
    */
   final String rootPrefix = path.rootPrefix(path.current);
 
   /**
    * A mapping of source path prefixes
    * from location where instrumentation or log file was generated
    * to the target location of the source using during performance measurement.
    */
-  final Map<String, String> srcPathMap;
+  final PathMap srcPathMap;
 
   /**
    * The root directory for all source being modified
    * during performance measurement.
    */
   final String tmpSrcDirPath;
 
-  /**
-   * The diagnostic port for Analysis Server or `null` if none.
-   */
-  final int diagnosticPort;
-
-  CommonInputConverter(this.tmpSrcDirPath, this.srcPathMap,
-      {this.diagnosticPort});
+  CommonInputConverter(this.tmpSrcDirPath, this.srcPathMap);
 
   /**
    * Return an operation for the notification or `null` if none.
    */
   Operation convertNotification(Map<String, dynamic> json) {
     String event = json['event'];
     if (event == SERVER_STATUS) {
       // {"event":"server.status","params":{"analysis":{"isAnalyzing":false}}}
       Map<String, dynamic> params = json['params'];
       if (params != null) {
         Map<String, dynamic> analysis = params['analysis'];
         if (analysis != null && analysis['isAnalyzing'] == false) {
           return new WaitForAnalysisCompleteOperation();
         }
       }
     }
     if (event == SERVER_CONNECTED) {
       // {"event":"server.connected","params":{"version":"1.7.0"}}
-      return new StartServerOperation(diagnosticPort: diagnosticPort);
+      return new StartServerOperation();
     }
     if (eventsSeen.add(event)) {
       logger.log(Level.INFO, 'Ignored notification: $event\n  $json');
     }
     return null;
   }
 
   /**
    * Return an operation for the request or `null` if none.
    */
@@ skipping 66 matching lines @@
   }
 
   /**
    * Return an operation for the recorded/expected response.
    */
   Operation convertResponse(Map<String, dynamic> json) {
     return new ResponseOperation(
         this, requestMap.remove(json['id']), translateSrcPaths(json));
   }
 
+  void logOverlayContent() {
+    logger.log(Level.WARNING, '${overlays.length} overlays');
+    List<String> allPaths = overlays.keys.toList()..sort();
+    for (String filePath in allPaths) {
+      logger.log(Level.WARNING, 'overlay $filePath\n${overlays[filePath]}');
+    }
+  }
+
   /**
    * Process an error response from the server by either
    * completing the associated completer in the [responseCompleters]
    * or stashing it in [responseMap] if no completer exists.
    */
   void processErrorResponse(String id, exception) {
     var result = exception;
     if (exception is UnimplementedError) {
       if (exception.message.startsWith(ERROR_PREFIX)) {
         result = JSON.decode(exception.message.substring(ERROR_PREFIX.length));
@@ skipping 40 matching lines @@
     }
   }
 
   /**
    * Recursively translate source paths in the specified JSON to reference
    * the temporary source used during performance measurement rather than
    * the original source when the instrumentation or log file was generated.
    */
   translateSrcPaths(json) {
     if (json is String) {
-      String result = json;
-      srcPathMap.forEach((String oldPrefix, String newPrefix) {
-        if (json.startsWith(oldPrefix)) {
-          result = '$newPrefix${json.substring(oldPrefix.length)}';
-        }
-      });
-      return result;
+      return srcPathMap.translate(json);
     }
     if (json is List) {
       List result = [];
       for (int i = 0; i < json.length; ++i) {
         result.add(translateSrcPaths(json[i]));
       }
       return result;
     }
     if (json is Map) {
       Map<String, dynamic> result = new Map<String, dynamic>();
@@ skipping 12 matching lines @@
  * The input stream can be either an instrumenation or log file.
  */
 class InputConverter extends Converter<String, Operation> {
   final Logger logger = new Logger('InputConverter');
 
   /**
    * A mapping of source path prefixes
    * from location where instrumentation or log file was generated
    * to the target location of the source using during performance measurement.
    */
-  final Map<String, String> srcPathMap;
+  final PathMap srcPathMap;
 
   /**
    * The root directory for all source being modified
    * during performance measurement.
    */
   final String tmpSrcDirPath;
 
   /**
-   * The diagnostic port for Analysis Server or `null` if none.
-   */
-  final int diagnosticPort;
-
-  /**
    * The number of lines read before the underlying converter was determined
    * or the end of file was reached.
    */
   int headerLineCount = 0;
 
   /**
    * The underlying converter used to translate lines into operations
    * or `null` if it has not yet been determined.
    */
   Converter<String, Operation> converter;
 
   /**
    * [active] is `true` if converting lines to operations
    * or `false` if an exception has occurred.
    */
   bool active = true;
 
-  InputConverter(this.tmpSrcDirPath, this.srcPathMap, {this.diagnosticPort});
+  InputConverter(this.tmpSrcDirPath, this.srcPathMap);
 
   @override
   Operation convert(String line) {
     if (!active) {
       return null;
     }
     if (converter != null) {
       try {
         return converter.convert(line);
       } catch (e) {
         active = false;
         rethrow;
       }
     }
     if (headerLineCount == 20) {
       throw 'Failed to determine input file format';
     }
     if (InstrumentationInputConverter.isFormat(line)) {
-      converter = new InstrumentationInputConverter(tmpSrcDirPath, srcPathMap,
-          diagnosticPort: diagnosticPort);
+      converter = new InstrumentationInputConverter(tmpSrcDirPath, srcPathMap);
     } else if (LogFileInputConverter.isFormat(line)) {
-      converter = new LogFileInputConverter(tmpSrcDirPath, srcPathMap,
-          diagnosticPort: diagnosticPort);
+      converter = new LogFileInputConverter(tmpSrcDirPath, srcPathMap);
     }
     if (converter != null) {
       return converter.convert(line);
     }
     logger.log(Level.INFO, 'skipped input line: $line');
     return null;
   }
 
   @override
   _InputSink startChunkedConversion(outSink) {
     return new _InputSink(this, outSink);
   }
 }
 
+/**
+ * A container of [PathMapEntry]s used to translate a source path in the log
+ * before it is sent to the analysis server.
+ */
+class PathMap {
+  final List<PathMapEntry> entries = [];
+
+  void add(String oldSrcPrefix, String newSrcPrefix) {
+    entries.add(new PathMapEntry(oldSrcPrefix, newSrcPrefix));
+  }
+
+  String translate(String original) {
+    String result = original;
+    for (PathMapEntry entry in entries) {
+      result = entry.translate(result);
+    }
+    return result;
+  }
+}
+
+/**
+ * An entry in [PathMap] used to translate a source path in the log
+ * before it is sent to the analysis server.
+ */
+class PathMapEntry {
+  final String oldSrcPrefix;
+  final String newSrcPrefix;
+
+  PathMapEntry(this.oldSrcPrefix, this.newSrcPrefix);
+
+  String translate(String original) {
+    return original.startsWith(oldSrcPrefix)
+        ? '$newSrcPrefix${original.substring(oldSrcPrefix.length)}'
+        : original;
+  }
+}
+
 class _InputSink extends ChunkedConversionSink<String> {
   final Converter<String, Operation> converter;
   final outSink;
 
   _InputSink(this.converter, this.outSink);
 
   @override
   void add(String line) {
     Operation op = converter.convert(line);
     if (op != null) {
       outSink.add(op);
     }
   }
 
   @override
   void close() {
     outSink.close();
   }
 }