Make pumpEventQueue() private and explain why it is used in 'results'.

pkg/analyzer/lib/src/dart/analysis/driver.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 213 matching lines @@
    * More than one result might be produced for the same file, even if the
    * client does not change the state of the files.
    *
    * Results might be produced even for files that have never been added
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results async* {
     try {
       PerformanceLogSection analysisSection = null;
       while (true) {
-        await pumpEventQueue(100);
+        // Pump the event queue to allow IO and other asynchronous data
+        // processing while analysis is active. For example Analysis Server
+        // needs to be able to process `updateContent` or `setPriorityFiles`
+        // requests while background analysis is in progress.
+        //
+        // The number of pumpings is arbitrary, might be changed if we see that
+        // analysis or other data processing tasks are starving. Ideally we
+        // would need to be able to set priority of (continuous) asynchronous
+        // tasks.
+        await _pumpEventQueue(128);
+
         await _hasWork.signal;
 
         if (analysisSection == null) {
           analysisSection = _logger.enter('Analyzing');
         }
 
         // Verify all changed files one at a time.
         if (_changedFiles.isNotEmpty) {
           String path = _removeFirst(_changedFiles);
           _verifyApiSignatureOfChangedFile(path);
@@ skipping 133 matching lines @@
 
   /**
    * Return `true` if the file with the given [path] was explicitly added
    * to analysis using [addFile].
    */
   bool isAddedFile(String path) {
     return _explicitFiles.contains(path);
   }
 
   /**
-   * Returns a [Future] that completes after pumping the event queue [times]
-   * times. By default, this should pump the event queue enough times to allow
-   * any code to run, as long as it's not waiting on some external event.
-   */
-  Future pumpEventQueue([int times = 5000]) {
-    if (times == 0) return new Future.value();
-    // We use a delayed future to allow microtask events to finish. The
-    // Future.value or Future() constructors use scheduleMicrotask themselves and
-    // would therefore not wait for microtask callbacks that are scheduled after
-    // invoking this method.
-    return new Future.delayed(Duration.ZERO, () => pumpEventQueue(times - 1));
-  }
-
-  /**
    * Remove the file with the given [path] from the list of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
     _explicitFiles.remove(path);
@@ skipping 314 matching lines @@
       // resolution results are invalid.
       if (oldSignature != null && oldSignature != newSignature) {
         _logger.writeln('API signatures mismatch found for $newFile');
         _dependencySignatureMap.clear();
         _filesToAnalyze.addAll(_explicitFiles);
       }
     });
   }
 
   /**
+   * Returns a [Future] that completes after performing [times] pumpings of
+   * the event queue.
+   */
+  static Future _pumpEventQueue(int times) {
+    if (times == 0) {
+      return new Future.value();
+    }
+    return new Future.delayed(Duration.ZERO, () => _pumpEventQueue(times - 1));
+  }
+
+  /**
    * Remove and return the first item in the given [set].
    */
   static Object/*=T*/ _removeFirst/*<T>*/(LinkedHashSet<Object/*=T*/ > set) {
     Object/*=T*/ element = set.first;
     set.remove(element);
     return element;
   }
 }
 
 /**
@@ skipping 484 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }