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(11244): remove second try when VM bug is fixed.

[Lasse Reichstein Nielsen, 2013/06/13 12:10:08]

Bug has been marked as duplicate of 430, so renumber comment.
Doesn't seem to be a priority - it's been open since Nov 2011.

[floitsch, 2013/06/13 14:38:55]

Done.

     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);
 
 /**
  * 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);
   }
 
+  /**
+   * 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.
  */
 class _ZoneTimer implements Timer {
   final _Zone _zone;
@@ skipping 39 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);
+runZonedExperimental(body(), { bool onError(error), void onDone() }) {

[Lasse Reichstein Nielsen, 2013/06/13 12:10:08]

I assume the name is experimental too :)

[floitsch, 2013/06/13 14:38:55]

I would keep the name. Until we feel comfortable that it sticks (for example wrt
DOM...)

+  // TODO(floitsch): we probably still want to install a new Zone.
+  if (onError == null && onDone == null) return body();
+  if (onError == null) {
+    _Zone 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 = () {};
+  _Zone zone = new _CatchErrorsZone(_Zone._current, onError, onDone);
+  return zone.runWaitForCompletion(body);
 }
-
-Future waitForCompletion(void body()) {
-  Completer completer = new Completer.sync();
-  _Zone zone = new _WaitForCompletionZone(_Zone._current, completer.complete);
-  zone.runWaitForCompletion(body);
-  return completer.future;
-}