Revert "Remove unused option in server API"

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';
 
+import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/config.dart';
+import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.dart';
+import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/task/options.dart';
@@ skipping 293 matching lines @@
   AnalysisContext addContext(Folder folder, AnalysisOptions options);
 
   /**
    * 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);
+
+  /**
    * Create and return a context builder that can be used to create a context
    * for the files in the given [folder] when analyzed using the given [options].
    */
   ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options);
 
   /**
    * Called when the context manager changes the folder with which a context is
    * associated. Currently this is mostly FYI, and used only in tests.
    */
   void moveContext(Folder from, Folder to);
@@ skipping 95 matching lines @@
   Map<String, String> normalizedPackageRoots = <String, String>{};
 
   /**
    * A function that will return a [UriResolver] that can be used to resolve
    * `package:` URI's within a given folder, or `null` if we should fall back
    * to the standard URI resolver.
    */
   final ResolverProvider packageResolverProvider;
 
   /**
-   * Provider of analysis options.
+   * Provider which is used to determine the mapping from package name to
+   * package folder.
    */
+  final PubPackageMapProvider _packageMapProvider;
+
+  /// Provider of analysis options.
   AnalysisOptionsProvider analysisOptionsProvider =
       new AnalysisOptionsProvider();
 
   /**
    * A list of the globs used to determine which files should be analyzed.
    */
   final List<Glob> analyzedFilesGlobs;
 
   /**
    * The default options used to create new analysis contexts.
@@ skipping 25 matching lines @@
    * 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.sdkManager,
       this.packageResolverProvider,
+      this._packageMapProvider,
       this.analyzedFilesGlobs,
       this._instrumentationService,
       this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   Iterable<AnalysisContext> get analysisContexts => folderMap.values;
 
@@ skipping 456 matching lines @@
           return new PackagesFileDisposition(packages);
         }
       }
       // 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 {
-      // Try .packages first.
-      if (absolutePathContext.basename(packagespecFile.path) ==
-          PACKAGE_SPEC_NAME) {
-        Packages packages = _readPackagespec(packagespecFile);
-        return new PackagesFileDisposition(packages);
+      PackageMapInfo packageMapInfo;
+      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 {
+        callbacks.computingPackageMap(false);
       }
-      if (packageResolverProvider != null) {
-        UriResolver resolver = packageResolverProvider(folder);
-        if (resolver != null) {
-          return new CustomPackageResolverDisposition(resolver);
-        }
+      for (String dependencyPath in packageMapInfo.dependencies) {
+        addDependency(dependencyPath);
       }
-      return new NoPackageFolderDisposition();
+      if (packageMapInfo.packageMap == null) {
+        return new NoPackageFolderDisposition();
+      }
+      return new PackageMapDisposition(packageMapInfo.packageMap);
     }
   }
 
   /**
    * Create a new empty context associated with [folder], having parent
    * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
       ContextInfo parent, Folder folder, File packagespecFile) {
     List<String> dependencies = <String>[];
@@ skipping 790 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }