catchErrors and waitForCompletion now based on runZonedExperimental.

sdk/lib/async/zone.dart

 // Copyright (c) 2013, 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.
 
 part of dart.async;
 
 /**
  * A Zone represents the asynchronous version of a dynamic extent. Asynchronous
  * callbacks are executed in the zone they have been queued in. For example,
  * the callback of a `future.then` is executed in the same zone as the one where
@@ skipping 219 matching lines @@
 
     _Zone oldZone = _Zone._current;
     _Zone._current = this;
     // While we are executing the function we don't want to have other
     // synchronous calls to think that they closed the zone. By incrementing
     // the _openCallbacks count we make sure that their test will fail.
     // As a side effect it will make nested calls faster since they are
     // (probably) in the same zone and have an _openCallbacks > 0.
     bool oldIsExecuting = _isExecutingCallback;
     _isExecutingCallback = true;
+    // TODO(430): remove second try when VM bug is fixed.
     try {
-      return fun();
-    } catch(e, s) {
-      if (handleUncaught) {
-        handleUncaughtError(_asyncError(e, s));
-      } else {
-        rethrow;
+      try {
+        return fun();
+      } catch(e, s) {
+        if (handleUncaught) {
+          handleUncaughtError(_asyncError(e, s));
+        } else {
+          rethrow;
+        }
       }
     } finally {
       _isExecutingCallback = oldIsExecuting;
       _Zone._current = oldZone;
       _checkIfDone();
     }
   }
 
   /**
    * Runs the function and catches uncaught errors.
    *
    * Uncaught errors are given to [handleUncaughtError].
    */
   _runGuarded(void fun()) {
-    _runInZone(fun, true);
+    return _runInZone(fun, true);
   }
 
   /**
    * Runs the function but doesn't catch uncaught errors.
    */
   _runUnguarded(void fun()) {
-    _runInZone(fun, false);
+    return _runInZone(fun, false);
   }
 
   runAsync(void fun()) {
     _openCallbacks++;
     _scheduleAsyncCallback(() {
       _openCallbacks--;
       _runGuarded(fun);
     });
   }
 
@@ skipping 59 matching lines @@
  */
 class _WaitForCompletionZone extends _ZoneBase {
   final _CompletionCallback _onDone;
 
   _WaitForCompletionZone(_Zone parentZone, this._onDone) : super(parentZone);
 
   /**
    * Runs the given function asynchronously. Executes the [_onDone] callback
    * when the zone is done.
    */
-  void runWaitForCompletion(void fun()) {
-    this._runGuarded(fun);
+  runWaitForCompletion(void fun()) {
+    return this._runUnguarded(fun);
   }
 
   _dispose() {
     super._dispose();
     _onDone();
   }
 
   String toString() => "WaitForCompletion ${super.toString()}";
 }
 
-typedef bool _HandleErrorCallback(error);
+typedef void _HandleErrorCallback(error);
 
 /**
  * A zone that collects all uncaught errors and provides them in a stream.
  * The stream is closed when the zone is done.
  */
 class _CatchErrorsZone extends _WaitForCompletionZone {
   final _HandleErrorCallback _handleError;
 
   _CatchErrorsZone(_Zone parentZone, this._handleError, void onDone())
     : super(parentZone, onDone);
 
   _Zone get _errorZone => this;
 
   handleUncaughtError(error) {
-    if (!_handleError(error)) _parentZone.handleUncaughtError(error);
+    try {
+      _handleError(error);
+    } catch(e, s) {
+      if (identical(e, s)) {
+        _parentZone.handleUncaughtError(error);
+      } else {
+        _parentZone.handleUncaughtError(_asyncError(e, s));
+      }
+    }
+  }
+
+  /**
+   * Runs the given function asynchronously. Executes the [_onDone] callback
+   * when the zone is done.
+   */
+  runWaitForCompletion(void fun()) {
+    return this._runGuarded(fun);
   }
 
   String toString() => "WithErrors ${super.toString()}";
 }
 
 typedef void _TimerCallback();
 
 /**
  * A [Timer] class that takes zones into account.
  */
@@ skipping 41 matching lines @@
     _zone.executePeriodicCallbackGuarded(() { _callback(this); });
   }
 
   void cancel() {
     if (!_isDone) _zone.cancelCallbackExpectation();
     _isDone = true;
     _timer.cancel();
   }
 }
 
-Stream catchErrors(void body()) {
-  _CatchErrorsZone catchErrorsZone;
-  StreamController controller;
-
-  void onListen() {
-    catchErrorsZone.runWaitForCompletion(body);
+/**
+ * Runs [body] in its own zone.
+ *
+ * If [onError] is non-null the zone is considered an error zone. All uncaught
+ * errors, synchronous or asynchronous, in the zone are caught and handled
+ * by the callback.
+ *
+ * [onDone] (if non-null) is invoked when the zone has no more outstanding
+ * callbacks.
+ *
+ * Examples:
+ *
+ *     runZonedExperimental(() {
+ *       new Future(() { throw "asynchronous error"; });
+ *     }, onError: print);  // Will print "asynchronous error".
+ *
+ * The following example prints "1", "2", "3", "4" in this order.
+ *
+ *     runZonedExperimental(() {
+ *       print(1);
+ *       new Future.value(3).then(print);
+ *     }, onDone: () { print(4); });
+ *     print(2);
+ *
+ * Errors may never cross error-zone boundaries. This is intuitive for leaving
+ * a zone, but it also applies for errors that would enter an error-zone.
+ * Errors that try to cross error-zone boundaries are considered uncaught.
+ *
+ *     var future = new Future.value(499);
+ *     runZonedExperimental(() {
+ *       future = future.then((_) { throw "error in first error-zone"; });
+ *       runZonedExperimental(() {
+ *         future = future.catchError((e) { print("Never reached!"); });
+ *       }, onError: (e) { print("unused error handler"); });
+ *     }, onError: (e) { print("catches error of first error-zone."); });
+ *
+ */
+runZonedExperimental(body(), { void onError(error), void onDone() }) {
+  // TODO(floitsch): we probably still want to install a new Zone.
+  if (onError == null && onDone == null) return body();
+  if (onError == null) {
+    _WaitForCompletionZone zone =
+        new _WaitForCompletionZone(_Zone._current, onDone);
+    return zone.runWaitForCompletion(body);
   }
-
-  bool handleError(e) {
-    controller.add(e);
-    return true;
-  }
-
-  void onDone() {
-    controller.close();
-  }
-
-  catchErrorsZone = new _CatchErrorsZone(_Zone._current, handleError, onDone);
-  controller = new StreamController(onListen: onListen);
-  return controller.stream;
+  if (onDone == null) onDone = _nullDoneHandler;
+  _CatchErrorsZone zone = new _CatchErrorsZone(_Zone._current, onError, onDone);
+  return zone.runWaitForCompletion(body);
 }
-
-Future waitForCompletion(void body()) {
-  Completer completer = new Completer.sync();
-  _WaitForCompletionZone zone =
-      new _WaitForCompletionZone(_Zone._current, completer.complete);
-  zone.runWaitForCompletion(body);
-  return completer.future;
-}