Fix bugs found while working on tests

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 93 matching lines @@
    * 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.
+   * used to interact with the plugin, or `null` if the plugin could not be run.
    */
   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);
+    bool isRunning = await currentSession.start(byteStorePath);
+    if (!isRunning) {
+      currentSession = null;
+    }
     return currentSession;
   }
 
   /**
    * Request that the plugin shutdown.
    */
   Future<Null> stop() {
     if (currentSession == null) {
       throw new StateError('Cannot stop a plugin that is not running.');
     }
@@ skipping 87 matching lines @@
     if (isNew) {
       List<String> pluginPaths = _pathsFor(path);
       if (pluginPaths == null) {
         return;
       }
       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((_) {
+        session?.onDone?.then((_) {
           _pluginMap.remove(path);
         });
       }
     }
     plugin.addContextRoot(contextRoot);
     if (isNew) {
       if (_analysisSetSubscriptionsParams != null) {
         plugin.sendRequest(_analysisSetSubscriptionsParams);
       }
       if (_overlayState.isNotEmpty) {
@@ skipping 397 matching lines @@
     }
     if (!isCompatible) {
       return false;
     }
     channel = new ServerIsolateChannel(
         new Uri.file(info.executionPath, windows: Platform.isWindows),
         new Uri.file(info.packagesPath, windows: Platform.isWindows),
         info.instrumentationService);
     await channel.listen(handleResponse, handleNotification,
         onDone: handleOnDone, onError: handleOnError);
+    if (channel == null) {
+      // If there is an error when starting the isolate, the channel will invoke
+      // handleOnDone, which will cause `channel` to be set to `null`.
+      return false;
+    }
     Response response = await sendRequest(
         new PluginVersionCheckParams(byteStorePath ?? '', '1.0.0-alpha.0'));
     PluginVersionCheckResult result =
         new PluginVersionCheckResult.fromResponse(response);
     isCompatible = result.isCompatible;
     contactInfo = result.contactInfo;
     interestingFiles = result.interestingFiles;
     name = result.name;
     version = result.version;
     if (!isCompatible) {
       sendRequest(new PluginShutdownParams());
       return false;
     }
     return true;
   }
 
   /**
    * Request that the plugin shutdown.
    */
   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;
   }
 }