Wait for InstrumentationService.shutdown() before exit(0).

pkg/analyzer/lib/instrumentation/instrumentation.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 instrumentation;
 
+import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/task/model.dart';
 
 /**
  * A container with analysis performance constants.
  */
 class AnalysisPerformanceKind {
   static const String FULL = 'analysis_full';
   static const String INCREMENTAL = 'analysis_incremental';
@@ skipping 19 matching lines @@
    * This method should only be used for logging high priority messages, such as
    * exceptions that cause the server to shutdown.
    */
   void logWithPriority(String message);
 
   /**
    * Signal that the client is done communicating with the instrumentation
    * server. This method should be invoked exactly one time and no other methods
    * should be invoked on this instance after this method has been invoked.
    */
-  void shutdown();
+  Future shutdown();
 }
 
 /**
  * The interface used by client code to communicate with an instrumentation
  * server by wrapping an [InstrumentationServer].
  */
 class InstrumentationService {
   /**
    * An instrumentation service that will not log any instrumentation data.
    */
@@ skipping 19 matching lines @@
    * if instrumentation data should not be logged.
    */
   InstrumentationServer _instrumentationServer;
 
   /**
    * Counter used to generate unique ID's for [logSubprocessStart].
    */
   int _subprocessCounter = 0;
 
   /**
-   * Initialize a newly created instrumentation service to comunicate with the
+   * Initialize a newly created instrumentation service to communicate with the
    * given [instrumentationServer].
    */
   InstrumentationService(this._instrumentationServer);
 
   /**
    * Return `true` if this [InstrumentationService] was initialized with a
    * non-`null` server (and hence instrumentation is active).
    */
   bool get isActive => _instrumentationServer != null;
 
@@ skipping 112 matching lines @@
 
   /**
    * Log that a response has been sent to the client.
    */
   void logResponse(String response) {
     _log(TAG_RESPONSE, response);
   }
 
   /**
    * Log the result of executing a subprocess.  [subprocessId] should be the
-   * unique IDreturned by [logSubprocessStart].
+   * unique ID returned by [logSubprocessStart].
    */
   void logSubprocessResult(
       int subprocessId, int exitCode, String stdout, String stderr) {
     if (_instrumentationServer != null) {
       _instrumentationServer.log(_join([
         TAG_SUBPROCESS_RESULT,
         subprocessId.toString(),
         exitCode.toString(),
         JSON.encode(stdout),
         JSON.encode(stderr)
@@ skipping 53 matching lines @@
       _instrumentationServer
           .log(_join([TAG_WATCH_EVENT, folderPath, filePath, changeType]));
     }
   }
 
   /**
    * Signal that the client is done communicating with the instrumentation
    * server. This method should be invoked exactly one time and no other methods
    * should be invoked on this instance after this method has been invoked.
    */
-  void shutdown() {
+  Future shutdown() async {
     if (_instrumentationServer != null) {
-      _instrumentationServer.shutdown();
+      await _instrumentationServer.shutdown();
       _instrumentationServer = null;
     }
   }
 
   /**
    * Write an escaped version of the given [field] to the given [buffer].
    */
   void _escape(StringBuffer buffer, String field) {
     int index = field.indexOf(':');
     if (index < 0) {
@@ skipping 60 matching lines @@
   }
 
   @override
   void logWithPriority(String message) {
     for (InstrumentationServer server in _servers) {
       server.logWithPriority(message);
     }
   }
 
   @override
-  void shutdown() {
+  Future shutdown() async {
     for (InstrumentationServer server in _servers) {
-      server.shutdown();
+      await server.shutdown();
     }
   }
 }