New scenario and local benchmark - refactoring after change.

pkg/analysis_server/benchmark/perf/benchmark_scenario.dart

 // Copyright (c) 2016, 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 server.performance.scenarios;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
@@ skipping 107 matching lines @@
       // Remove the overlay and analyze.
       await sendAnalysisUpdateContent({file: new RemoveContentOverlay()});
       await analysisFinished;
     }
     // Done.
     await shutdown();
     return times;
   }
 
   /**
+   * Init.
+   * 1. Start Analysis Server.
+   * 2. Set the analysis [roots].
+   * 3. Wait for analysis to complete.
+   * 4. Make [file] the priority file.
+   *
+   * Measurement.
+   * 5. Change the [file] according to the [fileChange].
+   * 6. Request [refactoringAtStr] in the updated file content.
+   * 7. Record the time to get refactoring.
+   * 8. Undo changes to the [file] and analyze.
+   * 9. Go to (5).
+   */
+  Future<List<int>> waitAnalyze_change_getRefactoring(
+      {List<String> roots,
+      String file,
+      FileChange fileChange,
+      String refactoringAtStr,
+      RefactoringKind refactoringKind,
+      RefactoringOptions refactoringOptions,
+      int numOfRepeats}) async {
+    expect(roots, isNotNull, reason: 'roots');
+    expect(file, isNotNull, reason: 'file');
+    expect(fileChange, isNotNull, reason: 'fileChange');
+    expect(refactoringAtStr, isNotNull, reason: 'refactoringAtStr');
+    expect(refactoringKind, isNotNull, reason: 'refactoringKind');
+    expect(refactoringOptions, isNotNull, reason: 'refactoringOptions');
+    expect(numOfRepeats, isNotNull, reason: 'numOfRepeats');
+    // Initialize Analysis Server.
+    await super.setUp();
+    await subscribeToStatusNotifications();
+    // Set roots and analyze.
+    await sendAnalysisSetAnalysisRoots(roots, []);
+    await analysisFinished;
+    // Make the file priority.
+    await sendAnalysisSetPriorityFiles([file]);
+    // Repeat.
+    List<int> times = <int>[];
+    for (int i = 0; i < numOfRepeats; i++) {
+      String updatedContent = await _applyFileChange(file, fileChange);
+      // Measure time to get refactoring.
+      int refactoringOffset = _indexOf(file, updatedContent, refactoringAtStr);
+      Duration refactoringDuration = await _measureRefactoringTime(
+          file, refactoringOffset, refactoringKind, refactoringOptions);
+      times.add(refactoringDuration.inMilliseconds);
+      // Remove the overlay and analyze.
+      await sendAnalysisUpdateContent({file: new RemoveContentOverlay()});
+      await analysisFinished;
+    }
+    // Done.
+    await shutdown();
+    return times;
+  }
+
+  /**
    * Compute updated content of the [file] as described by [desc], add overlay
    * for the [file], and return the updated content.
    */
   Future<String> _applyFileChange(String file, FileChange desc) async {
     String originalContent = _getFileContent(file);
     int offset = _indexOfEnd(file, originalContent, desc.afterStr);
     offset -= desc.afterStrBack;
     String updatedContent = originalContent.substring(0, offset) +
         desc.insertStr +
         originalContent.substring(offset);
@@ skipping 10 matching lines @@
       completer.complete(stopwatch.elapsed);
     });
     try {
       await sendCompletionGetSuggestions(file, offset);
       return await completer.future;
     } finally {
       completionSubscription.cancel();
     }
   }
 
+  Future<Duration> _measureRefactoringTime(
+      String file,
+      int offset,
+      RefactoringKind refactoringKind,
+      RefactoringOptions refactoringOptions) async {
+    Stopwatch stopwatch = new Stopwatch();
+    stopwatch.start();
+    await sendEditGetRefactoring(refactoringKind, file, offset, 0, false,
+        options: refactoringOptions);
+    return stopwatch.elapsed;
+  }
+
   /**
    *  1. Start Analysis Server.
    *  2. Set the analysis [roots].
    *  3. Wait for analysis to complete.
    *  4. Record the time to finish analysis.
    *  5. Shutdown.
    *  6. Go to (1).
    */
   static Future<List<int>> start_waitInitialAnalysis_shutdown(
       {List<String> roots, int numOfRepeats}) async {
@@ skipping 43 matching lines @@
 class FileChange {
   final String afterStr;
   final int afterStrBack;
   final String insertStr;
 
   FileChange({this.afterStr, this.afterStrBack: 0, this.insertStr}) {
     expect(afterStr, isNotNull, reason: 'afterStr');
     expect(insertStr, isNotNull, reason: 'insertStr');
   }
 }