Partially revert notification of package map computation

pkg/analysis_server/lib/src/context_manager.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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
@@ skipping 232 matching lines @@
    */
   List<String> get excludedPaths;
 
   /**
    * Return the list of included paths (folders and files) most recently passed
    * to [setRoots].
    */
   List<String> get includedPaths;
 
   /**
-   * The stream that is notified when we are starting or ending the computation
-   * of a package map. A value of `true` is added when the computation starts
-   * and a value of `false` is added when the computation ends.
-   */
-  Stream<bool> get onComputingPackageMap;
-
-  /**
    * Return a list of all of the contexts reachable from the given
    * [analysisRoot] (the context associated with [analysisRoot] and all of its
    * descendants).
    */
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot);
 
   /**
    * Return the [AnalysisContext] for the "innermost" context whose associated
    * folder is or contains the given path.  ("innermost" refers to the nesting
    * of contexts, so if there is a context for path /foo and a context for
@@ skipping 52 matching lines @@
       Folder folder, AnalysisOptions options, FolderDisposition disposition);
 
   /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
+   * Signals that the context manager has started to compute a package map (if
+   * [computing] is `true`) or has finished (if [computing] is `false`).
+   */
+  void computingPackageMap(bool computing);
+
+  /**
    * Remove the context associated with the given [folder].  [flushedFiles] is
    * a list of the files which will be "orphaned" by removing this context
    * (they will no longer be analyzed by any context).
    */
   void removeContext(Folder folder, List<String> flushedFiles);
 
   /**
    * Return `true` if the given [file] should be analyzed.
    */
   bool shouldFileBeAnalyzed(File file);
@@ skipping 112 matching lines @@
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
   final ContextInfo rootInfo = new ContextInfo._root();
 
   /**
-   * The controller that is notified when we are starting or ending the
-   * computation of a package map.
-   */
-  StreamController<bool> _onComputingPackageMapController;
-
-  /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(
       this.resourceProvider,
       this.packageResolverProvider,
       this.embeddedUriResolverProvider,
       this._packageMapProvider,
       this._instrumentationService,
       this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
-    _onComputingPackageMapController = new StreamController.broadcast();
   }
 
   @override
-  Stream<bool> get onComputingPackageMap {
-    return _onComputingPackageMapController.stream;
-  }
-
-  @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
         _getInnermostContextInfoFor(analysisRoot.path);
     void addContextAndDescendants(ContextInfo info) {
       contexts.add(info.context);
       info.children.forEach(addContextAndDescendants);
     }
     if (innermostContainingInfo != null) {
       if (analysisRoot == innermostContainingInfo.folder) {
@@ skipping 487 matching lines @@
         }
       }
       // The package root does not exist (or is not a folder).  Since
       // [setRoots] ignores any package roots that don't exist (or aren't
       // folders), the only way we should be able to get here is due to a race
       // condition.  In any case, the package root folder is gone, so we can't
       // resolve packages.
       return new NoPackageFolderDisposition(packageRoot: packageRoot);
     } else {
       PackageMapInfo packageMapInfo;
-      _onComputingPackageMapController.add(true);
+      callbacks.computingPackageMap(true);
       try {
         // Try .packages first.
         if (absolutePathContext.basename(packagespecFile.path) ==
             PACKAGE_SPEC_NAME) {
           Packages packages = _readPackagespec(packagespecFile);
           return new PackagesFileDisposition(packages);
         }
         if (packageResolverProvider != null) {
           UriResolver resolver = packageResolverProvider(folder);
           if (resolver != null) {
             return new CustomPackageResolverDisposition(resolver);
           }
         }
 
         ServerPerformanceStatistics.pub.makeCurrentWhile(() {
           packageMapInfo = _packageMapProvider.computePackageMap(folder);
         });
       } finally {
-        _onComputingPackageMapController.add(false);
+        callbacks.computingPackageMap(false);
       }
       for (String dependencyPath in packageMapInfo.dependencies) {
         addDependency(dependencyPath);
       }
       if (packageMapInfo.packageMap == null) {
         return new NoPackageFolderDisposition();
       }
       return new PackageMapDisposition(packageMapInfo.packageMap);
     }
   }
@@ skipping 648 matching lines @@
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }