Add Isolate.onExit.

sdk/lib/isolate/isolate.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Concurrent programming using _isolates_:
  * independent workers that are similar to threads
  * but don't share memory,
  * communicating only via messages.
  *
@@ skipping 18 matching lines @@
 }
 
 class Isolate {
   /**
    * Control port used to send control messages to the isolate.
    *
    * This class provides helper functions that sends control messages
    * to the control port.
    */
   final SendPort controlPort;
+  /**
+   * Capability granting the ability to pause the isolate.
+   */
   final Capability pauseCapability;
+  /**
+   * Capability granting the ability to inspect the isolate.
+   *
+   * This capability is needed to be able to see uncaught errors and exit of
+   * the isolate.

[floitsch, 2014/02/25 19:25:48]

I don't think inspecting is the same as being able to see uncaught errors and
exits of isolates.
I have definitely less problems letting someone else know, that I died, than
allowing him to extract all my cookie-information.

[Lasse Reichstein Nielsen, 2014/02/27 08:04:28]

Would "observe" be a better word. It suggests a more hands-off view of only
external behavior, where "inspect" is more like peeking into the internals?

+   */
+  final Capability inspectCapability;
 
-  Isolate._fromControlPort(this.controlPort, [this.pauseCapability]);
+  Isolate._fromControlPort(this.controlPort, [this.pauseCapability,
+                                              this.inspectCapability]);
 
   /**
    * Creates and spawns an isolate that shares the same code as the current
    * isolate.
    *
    * The argument [entryPoint] specifies the entry point of the spawned
    * isolate. It must be a top-level function or a static method that
    * takes one argument - that is, one-parameter functions that can be
    * compile-time constant function values.
    * It is not allowed to pass the value of function expressions or an instance
@@ skipping 37 matching lines @@
    *
    * The isolate should stop handling events by pausing its event queue.
    * The request will eventually make the isolate stop doing anything.
    * It will be handled before any other messages sent to the isolate from
    * the current isolate, but no other guarantees are provided.
    *
    * If [resumeCapability] is provided, it is used to identity the pause,
    * and must be used again to end the pause using [resume].
    * Otherwise a new capability is created and returned.
    *
-   * If an isolate is paused more than once using the same capabilty,
+   * If an isolate is paused more than once using the same capability,
    * only one resume with that capability is needed to end the pause.
    *
    * If an isolate is paused using more than one capability,
    * they must all be individully ended before the isolate resumes.
    *
    * Returns the capability that must be used to resume end the pause.
    *
    * WARNING: This method is not handled on any platform yet.
    */
   Capability pause([Capability resumeCapability]) {
@@ skipping 16 matching lines @@
    * isolate, otherwise the resume call does nothing.
    *
    * WARNING: This method is not handled on any platform yet.
    */
   void resume(Capability resumeCapability) {
     var message = new List(2)
         ..[0] = "resume"
         ..[1] = resumeCapability;
     controlPort.send(message);
   }
+
+  /**
+   * Returns a future that completes after the isolate has terminated.
+   */
+  Future get onExit {
+    // Should we return a broadcast stream instead? It has the advantage

[floitsch, 2014/02/25 19:25:48]

I don't see any stream.

[Lasse Reichstein Nielsen, 2014/02/27 08:04:28]

No, I was suggesting a broadcast stream instead of a future.
The stream would only ever send a "done" message, so it seems like overdoing it,
but on the other hand, it allows listening, and unlistening again, which a
future doesn't.

+    // that you can stop listening again.
+    var completer = new Completer();
+    var receivePort;
+    receivePort = new RawReceivePort((_) {
+      completer.complete();
+      receivePort.close();
+    });
+    var message = new List(3)
+        ..[0] = "ondone"
+        ..[1] = inspectCapability
+        ..[2] = receivePort.sendPort;
+    controlPort.send(message);
+    return completer.future;
+  }
 }
 
 /**
  * Sends messages to its [ReceivePort]s.
  *
  * [SendPort]s are created from [ReceivePort]s. Any message sent through
  * a [SendPort] is delivered to its corresponding [ReceivePort]. There might be
  * many [SendPort]s for the same [ReceivePort].
  *
  * [SendPort]s can be transmitted to other isolates.
@@ skipping 145 matching lines @@
   const _IsolateUnhandledException(this.message, this.source, this.stackTrace);
 
   String toString() {
     return 'IsolateUnhandledException: exception while handling message: '
         '${message} \n  '
         '${source.toString().replaceAll("\n", "\n  ")}\n'
         'original stack trace:\n  '
         '${stackTrace.toString().replaceAll("\n","\n  ")}';
   }
 }