Add support for three more plugin requests

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:io' show Platform;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analyzer/context/context_root.dart' as analyzer;
@@ skipping 80 matching lines @@
    * Remove the given [contextRoot] from the set of context roots being analyzed
    * by this plugin.
    */
   void removeContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoots.remove(contextRoot)) {
       _updatePluginRoots();
     }
   }
 
   /**
+   * If the plugin is currently running, send a request based on the given
+   * [params] to the plugin. If the plugin is not running, the request will
+   * silently be dropped.
+   */
+  void sendRequest(RequestParams params) {
+    currentSession?.sendRequest(params);
+  }
+
+  /**
    * Start a new isolate that is running the plugin. Return the state object
    * used to interact with the plugin.
    */
   Future<PluginSession> start(String byteStorePath) async {
     if (currentSession != null) {
       throw new StateError('Cannot start a plugin that is already running.');
     }
     currentSession = new PluginSession(this);
     await currentSession.start(byteStorePath);
     return currentSession;
@@ skipping 50 matching lines @@
    * The instrumentation service that is being used by the analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
    * 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;
+
+  /**
+   * The parameters for the last 'analysis.setSubscriptions' 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.
+   */
+  AnalysisSetSubscriptionsParams _analysisSetSubscriptionsParams;
+
+  /**
+   * The current state of content overlays. Because plugins are lazily
+   * 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.notificationManager, this.instrumentationService);
 
   /**
    * 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 {
     PluginInfo plugin = _pluginMap[path];
+    bool isNew = false;
     if (plugin == null) {
+      isNew = true;
       List<String> pluginPaths = _pathsFor(path);
       plugin = new PluginInfo(path, pluginPaths[0], pluginPaths[1],
           notificationManager, instrumentationService);
       _pluginMap[path] = plugin;
       if (pluginPaths[0] != null) {
         PluginSession session = await plugin.start(byteStorePath);
         session.onDone.then((_) {
           _pluginMap.remove(path);
         });
       }
     }
     plugin.addContextRoot(contextRoot);
+    if (isNew) {
+      if (_analysisSetSubscriptionsParams != null) {
+        plugin.sendRequest(_analysisSetSubscriptionsParams);
+      }
+      if (_overlayState.isNotEmpty) {
+        plugin.sendRequest(new AnalysisUpdateContentParams(_overlayState));
+      }
+      if (_analysisSetPriorityFilesParams != null) {
+        plugin.sendRequest(_analysisSetPriorityFilesParams);
+      }
+    }
   }
 
   /**
    * Broadcast a request built from the given [params] to all of the plugins
    * that are currently associated with the given [contextRoot]. Return a list
    * containing futures that will complete when each of the plugins have sent a
    * response.
    */
   Map<PluginInfo, Future<Response>> broadcast(
       analyzer.ContextRoot contextRoot, RequestParams params) {
@@ skipping 29 matching lines @@
     for (PluginInfo plugin in plugins) {
       plugin.removeContextRoot(contextRoot);
       if (plugin.contextRoots.isEmpty) {
         _pluginMap.remove(plugin.path);
         plugin.stop();
       }
     }
   }
 
   /**
+   * Send a request based on the given [params] to existing plugins to set the
+   * priority files to those specified by the [params]. As a side-effect, record
+   * the parameters so that they can be sent to any newly started plugins.
+   */
+  void setAnalysisSetPriorityFilesParams(
+      AnalysisSetPriorityFilesParams params) {
+    for (PluginInfo plugin in _pluginMap.values) {
+      plugin.sendRequest(params);
+    }
+    _analysisSetPriorityFilesParams = params;
+  }
+
+  /**
+   * Send a request based on the given [params] to existing plugins to set the
+   * subscriptions to those specified by the [params]. As a side-effect, record
+   * the parameters so that they can be sent to any newly started plugins.
+   */
+  void setAnalysisSetSubscriptionsParams(
+      AnalysisSetSubscriptionsParams params) {
+    for (PluginInfo plugin in _pluginMap.values) {
+      plugin.sendRequest(params);
+    }
+    _analysisSetSubscriptionsParams = params;
+  }
+
+  /**
+   * Send a request based on the given [params] to existing plugins to set the
+   * content overlays to those specified by the [params]. As a side-effect,
+   * update the overlay state so that it can be sent to any newly started
+   * plugins.
+   */
+  void setAnalysisUpdateContentParams(AnalysisUpdateContentParams params) {
+    for (PluginInfo plugin in _pluginMap.values) {
+      plugin.sendRequest(params);
+    }
+    Map<String, dynamic> files = params.files;
+    for (String file in files.keys) {
+      Object overlay = files[file];
+      if (overlay is RemoveContentOverlay) {
+        _overlayState.remove(file);
+      } else if (overlay is AddContentOverlay) {
+        _overlayState[file] = overlay;
+      } else if (overlay is ChangeContentOverlay) {
+        AddContentOverlay previousOverlay = _overlayState[file];
+        String newContent =
+            SourceEdit.applySequence(previousOverlay.content, overlay.edits);
+        _overlayState[file] = new AddContentOverlay(newContent);
+      } else {
+        throw new ArgumentError(
+            'Invalid class of overlay: ${overlay.runtimeType}');
+      }
+    }
+  }
+
+  /**
    * Stop all of the plugins that are currently running.
    */
   Future<List<Null>> stopAll() {
     return Future.wait(_pluginMap.values.map((PluginInfo info) => info.stop()));
   }
 
   /**
    * Return the execution path and .packages path associated with the plugin at
    * the given [path], or `null` if there is a problem that prevents us from
    * executing the plugin.
@@ skipping 245 matching lines @@
   Future<Null> stop() {
     if (channel == null) {
       throw new StateError('Cannot stop a plugin that is not running.');
     }
     // TODO(brianwilkerson) Ensure that the isolate is killed if it does not
     // terminate normally.
     sendRequest(new PluginShutdownParams());
     return pluginStoppedCompleter.future;
   }
 }