Remove the auto-discovery of plugins

pkg/analysis_server/lib/src/plugin/plugin_manager.dart

 // Copyright (c) 2017, 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 'dart:io' show Platform, Process, ProcessResult;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
@@ skipping 273 matching lines @@
    * The object used to manage the receiving and sending of notifications.
    */
   final NotificationManager notificationManager;
 
   /**
    * The instrumentation service that is being used by the analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
-   * The list of globs used to match plugin paths that have been whitelisted.
-   */
-  List<Glob> _whitelistGlobs;
-
-  /**
    * A table mapping the paths of plugins to information about those plugins.
    */
   Map<String, PluginInfo> _pluginMap = <String, PluginInfo>{};
 
   /**
    * The parameters for the last 'analysis.setPriorityFiles' request that was
    * received from the client. Because plugins are lazily discovered, this needs
    * to be retained so that it can be sent after a plugin has been started.
    */
   AnalysisSetPriorityFilesParams _analysisSetPriorityFilesParams;
@@ skipping 10 matching lines @@
    * discovered, the state needs to be retained so that it can be sent after a
    * plugin has been started.
    */
   Map<String, dynamic> _overlayState = <String, dynamic>{};
 
   /**
    * Initialize a newly created plugin manager. The notifications from the
    * running plugins will be handled by the given [notificationManager].
    */
   PluginManager(this.resourceProvider, this.byteStorePath, this.sdkPath,
-      this.notificationManager, this.instrumentationService) {
-    // TODO(brianwilkerson) Figure out the right list of plugin paths.
-    _whitelistGlobs = <Glob>[
-      new Glob(resourceProvider.pathContext.separator,
-          '**/angular_analyzer_plugin/tools/analyzer_plugin'),
-      new Glob(resourceProvider.pathContext.separator,
-          '**angular/tools/analyzer_plugin')
-    ];
-  }
+      this.notificationManager, this.instrumentationService);
 
   /**
    * Return a list of all of the plugins that are currently known.
    */
   @visibleForTesting
   List<PluginInfo> get plugins => _pluginMap.values.toList();
 
   /**
    * Add the plugin with the given [path] to the list of plugins that should be
    * used when analyzing code for the given [contextRoot]. If the plugin had not
    * yet been started, then it will be started by this method.
    */
   Future<Null> addPluginToContextRoot(
       analyzer.ContextRoot contextRoot, String path) async {
-    if (!_isWhitelisted(path)) {
-      return;
-    }
     PluginInfo plugin = _pluginMap[path];
     bool isNew = plugin == null;
     if (isNew) {
       List<String> pluginPaths = pathsFor(path);
       if (pluginPaths == null) {
         return;
       }
       plugin = new DiscoveredPluginInfo(path, pluginPaths[0], pluginPaths[1],
           notificationManager, instrumentationService);
       _pluginMap[path] = plugin;
@@ skipping 241 matching lines @@
   }
 
   /**
    * Stop all of the plugins that are currently running.
    */
   Future<List<Null>> stopAll() {
     return Future.wait(_pluginMap.values.map((PluginInfo info) => info.stop()));
   }
 
   /**
-   * Whitelist all plugins.
-   */
-  @visibleForTesting
-  void whitelistEverything() {
-    _whitelistGlobs = <Glob>[
-      new Glob(resourceProvider.pathContext.separator, '**/*')
-    ];
-  }
-
-  /**
    * Compute the paths to be returned by the enclosing method given that the
    * plugin should exist in the given [pluginFolder].
    */
   List<String> _computePaths(Folder pluginFolder,
       {bool runPub: false, Workspace workspace}) {
     File pluginFile = pluginFolder
         .getChildAssumingFolder('bin')
         .getChildAssumingFile('plugin.dart');
     if (!pluginFile.exists) {
       return null;
@@ skipping 98 matching lines @@
       } catch (exception) {
         // If we are not able to produce a .packages file, return null so that
         // callers will not try to load the plugin.
         return null;
       }
     }
     return packagesFile;
   }
 
   /**
-   * Return `true` if the plugin with the given [path] has been whitelisted.
-   */
-  bool _isWhitelisted(String path) {
-    for (Glob glob in _whitelistGlobs) {
-      if (glob.matches(path)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
    * Return the names of packages that are listed as dependencies in the given
    * [pubspecFile].
    */
   Iterable<String> _readDependecies(File pubspecFile) {
     YamlDocument document = loadYamlDocument(pubspecFile.readAsStringSync(),
         sourceUrl: pubspecFile.toUri());
     YamlNode contents = document.contents;
     if (contents is YamlMap) {
       YamlNode dependencies = contents['dependencies'];
       if (dependencies is YamlMap) {
@@ skipping 274 matching lines @@
    * The completer that will be used to complete the future when the response is
    * received from the plugin.
    */
   final Completer<Response> completer;
 
   /**
    * Initialize a pending request.
    */
   _PendingRequest(this.method, this.requestTime, this.completer);
 }