Add an error listener on isolates.

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 29 matching lines @@
    * 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 terminate the isolate.
    */
   final Capability terminateCapability;
 
   /**
    * Create a new [Isolate] object with a restricted set of capabilities.
    *
    * The port should be a control port for an isolate, as taken from
    * another `Isolate` object.
@@ skipping 231 matching lines @@
    *     messages that affect normal events, including `pause`.
    *     This can be used to wait for a another event to be processed.
    */
   void ping(SendPort responsePort, [int pingType = IMMEDIATE]) {
     var message = new List(3)
         ..[0] = "ping"
         ..[1] = responsePort
         ..[2] = pingType;
     controlPort.send(message);
   }
+
+  /**
+   * Requests that uncaught errors of the isolate are sent back to [port].
+   *
+   * The errors are sent back as two elements lists.
+   * The first element is a `String` representation of the error, usually
+   * created by calling `toString` on the error.
+   * The second element is a `String` representation of an accompanying
+   * stack trace, or `null` if no stack trace was provided.
+   *
+   * Listening using the same port more than once does nothing. It will only
+   * get each error once.
+   */
+  void addErrorListener(SendPort port) {
+    var message = new List(2)
+        ..[0] = "getErrors"
+        ..[1] = port;
+    controlPort.send(message);
+  }
+
+  /**
+   * Stop listening for uncaught errors through [port].
+   *
+   * The `port` should be a port that is listening for errors through
+   * [addErrorListener]. This call requests that the isolate stops sending
+   * errors on the port.
+   *
+   * If the same port has been passed via `addErrorListener` more than once,
+   * only one call to `removeErrorListener` is needed to stop it from receiving
+   * errors.
+   *
+   * Closing the receive port at the end of the send port will not stop the
+   * isolate from sending errors, they are just going to be lost.
+   */
+  void removeErrorListener(SendPort port) {
+    var message = new List(2)
+        ..[0] = "stopErrors"
+        ..[1] = port;
+    controlPort.send(message);
+  }
+
+  /**
+   * Returns a broadcast stream of uncaught errors from the isolate.
+   *
+   * Each error is provided as an error event on the stream.
+   *
+   * The actual error object and stackTraces will not necessarily
+   * be the same object types as in the actual isolate, but they will
+   * always have the same [Object.toString] result.
+   *
+   * This stream is based on [addErrorListener] and [removeErrorListener].
+   */
+  Stream get errors {
+    StreamController controller;
+    RawReceivePort port;
+    void handleError(message) {
+      String errorDescription = message[0];
+      String stackDescription = message[1];
+      var error = new RemoteError(errorDescription, stackDescription);
+      controller.addError(error, error.stackTrace);
+    }
+    controller = new StreamController.broadcast(
+        sync: true,
+        onListen: () {
+          port = new RawReceivePort(handleError);
+          this.addErrorListener(port.sendPort);
+        },
+        onCancel: () {
+          this.removeErrorListener(port.sendPort);
+          port.close();
+          port = null;
+        });
+    return controller.stream;
+  }
 }
 
 /**
  * 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, and they preserve equality
@@ skipping 146 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  ")}';
   }
 }
+
+/**
+ * Description of an error from another isolate.
+ *
+ * This error has the same `toString()` and `stackTrace.toString()` behavior
+ * as the original error, but has no other features of the original error.
+ */
+class RemoteError implements Error {
+  final String _description;
+  final StackTrace stackTrace;
+  RemoteError(String description, String stackDescription)
+      : _description = description,
+        stackTrace = new _RemoteStackTrace(stackDescription);
+  String toString() => _description;
+}
+
+class _RemoteStackTrace implements StackTrace {
+  String _trace;
+  _RemoteStackTrace(this._trace);
+  String toString() => _trace;
+}