Expose Zones.

sdk/lib/async/future_impl.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.
 
 part of dart.async;
 
 /** The onValue and onError handlers return either a value or a future */
 typedef dynamic _FutureOnValue<T>(T value);
 typedef dynamic _FutureOnError(error);
 /** Test used by [Future.catchError] to handle skip some errors. */
@@ skipping 58 matching lines @@
   // just use the PENDING_COMPLETE state instead.
   static const int _CHAINED = 2;
   /// The future has been completed with a value result.
   static const int _VALUE = 4;
   /// The future has been completed with an error result.
   static const int _ERROR = 8;
 
   /** Whether the future is complete, and as what. */
   int _state = _INCOMPLETE;
 
-  final _Zone _zone = _Zone.current.fork();
+  final Zone _zone = Zone.current;
 
   bool get _mayComplete => _state == _INCOMPLETE;
   bool get _isChained => _state == _CHAINED;
   bool get _isComplete => _state >= _VALUE;
   bool get _hasValue => _state == _VALUE;
   bool get _hasError => _state == _ERROR;
 
   set _isChained(bool value) {
     if (value) {
       assert(!_isComplete);
@@ skipping 58 matching lines @@
           _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncComplete(value);
   }
 
   _Future.immediateError(var error, [Object stackTrace])
       : _onValueCallback = null, _errorTestCallback = null,
         _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncCompleteError(error, stackTrace);
   }
 
-  _Future._then(this._onValueCallback, this._onErrorCallback)
-      : _errorTestCallback = null, _whenCompleteActionCallback = null {
-    _zone.expectCallback();
-  }
+  _Future._then(onValueCallback(value), onErrorCallback(e))
+      : _onValueCallback = Zone._current.registerCallback1(onValueCallback),
+        _onErrorCallback = Zone._current.registerCallback1(onErrorCallback),
+        _errorTestCallback = null,
+        _whenCompleteActionCallback = null;
 
-  _Future._catchError(this._onErrorCallback, this._errorTestCallback)
-    : _onValueCallback = null, _whenCompleteActionCallback = null {
-    _zone.expectCallback();
-  }
+  _Future._catchError(onErrorCallback(e), bool errorTestCallback(e))
+    : _onErrorCallback = Zone._current.registerCallback1(onErrorCallback),
+      _errorTestCallback = Zone._current.registerCallback1(errorTestCallback),
+      _onValueCallback = null,
+      _whenCompleteActionCallback = null;
 
-  _Future._whenComplete(this._whenCompleteActionCallback)
-      : _onValueCallback = null, _errorTestCallback = null,
-        _onErrorCallback = null {
-    _zone.expectCallback();
-  }
+  _Future._whenComplete(whenCompleteActionCallback())
+      : _whenCompleteActionCallback =
+            Zone._current.registerCallback(whenCompleteActionCallback),
+        _onValueCallback = null,
+        _errorTestCallback = null,
+        _onErrorCallback = null;
 
   Future then(f(T value), { onError(error) }) {
     _Future result;
     result = new _Future._then(f, onError);
     _addListener(result);
     return result;
   }
 
   Future catchError(f(error), { bool test(error) }) {
     _Future result = new _Future._catchError(f, test);
@@ skipping 33 matching lines @@
   void _setError(Object error) {
     assert(!_isComplete);  // But may have a completion pending.
     _state = _ERROR;
     _resultOrListeners = error;
   }
 
   void _addListener(_Future listener) {
     assert(listener._nextListener == null);
     if (_isComplete) {
       // Handle late listeners asynchronously.
-      runAsync(() {
+      _zone.runAsync(() {
         _propagateToListeners(this, listener);
       });
     } else {
       listener._nextListener = _resultOrListeners;
       _resultOrListeners = listener;
     }
   }
 
   _Future _removeListeners() {
     // Reverse listeners before returning them, so the resulting list is in
@@ skipping 88 matching lines @@
         (value is! _Future || !(value as _Future)._isComplete)) {
       // Case 2 from above. We need to register.
       // Note that we are still completing asynchronously: either we register
       // through .then (in which case the completing is asynchronous), or we
       // have a _Future which isn't complete yet.
       _complete(value);
       return;
     }
 
     _markPendingCompletion();
-    runAsync(() {
+    _zone.runAsync(() {
       _complete(value);
     });
   }
 
   void _asyncCompleteError(error, [StackTrace stackTrace]) {
     assert(!_isComplete);
     assert(_onValue == null);
     assert(_onError == null);
     assert(_whenCompleteAction == null);
     assert(_errorTest == null);
 
     _markPendingCompletion();
-    runAsync(() {
+    _zone.runAsync(() {
       _completeError(error, stackTrace);
     });
   }
 
   /**
    * Propagates the value/error of [source] to its [listeners].
    *
    * Unlinks all listeners and propagates the source to each listener
    * separately.
    */
@@ skipping 30 matching lines @@
         // Usually futures only have one listener. If they have several, we
         // handle them specially.
         _propagateMultipleListeners(source, listeners);
         return;
       }
       if (hasError && !source._zone.inSameErrorZone(listener._zone)) {
         // Don't cross zone boundaries with errors.
         source._zone.handleUncaughtError(source._error);
         return;
       }
-      if (!identical(_Zone.current, listener._zone)) {
+      if (!identical(Zone.current, listener._zone)) {
         // Run the propagation in the listener's zone to avoid
         // zone transitions. The idea is that many chained futures will
         // be in the same zone.
-        listener._zone.executePeriodicCallback(() {
+        listener._zone.run(() {
           _propagateToListeners(source, listener);
         });
         return;
       }
 
       // Do the actual propagation.
       // TODO(floitsch): Do we need to go through the zone even if we
       // don't have a callback to execute?
       bool listenerHasValue;
       var listenerValueOrError;
       // Set to true if a whenComplete needs to wait for a future.
       // The whenComplete action will resume the propagation by itself.
       bool isPropagationAborted = false;
       // Even though we are already in the right zone (due to the optimization
       // above), we still need to go through the zone. The overhead of
       // executeCallback is however smaller when it is already in the correct
       // zone.
       // TODO(floitsch): only run callbacks in the zone, not the whole
       // handling code.
-      listener._zone.executeCallback(() {
+      listener._zone.run(() {
         // TODO(floitsch): mark the listener as pending completion. Currently
         // we can't do this, since the markPendingCompletion verifies that
         // the future is not already marked (or chained).
         try {
           if (!hasError) {
             var value = source._value;
             if (listener._onValue != null) {
               listenerValueOrError = listener._onValue(value);
               listenerHasValue = true;
             } else {
@@ skipping 29 matching lines @@
                 // When there is an error, we have to make the error the new
                 // result of the current listener.
                 if (completeResult is! _Future) {
                   // This should be a rare case.
                   completeResult = new _Future();
                   completeResult._setError(error);
                 }
                 _propagateToListeners(completeResult, listener);
               });
               isPropagationAborted = true;
-              // We will reenter the listener's zone.
-              listener._zone.expectCallback();
             }
           }
         } catch (e, s) {
           // Set the exception as error.
           listenerValueOrError = _asyncError(e, s);
           listenerHasValue = false;
         }
-        if (listenerHasValue && listenerValueOrError is Future) {
-          // We are going to reenter the zone to finish what we started.
-          listener._zone.expectCallback();
-        }
       });
       if (isPropagationAborted) return;
       // If the listener's value is a future we need to chain it.
       if (listenerHasValue && listenerValueOrError is Future) {
         Future chainSource = listenerValueOrError;
         // Shortcut if the chain-source is already completed. Just continue the
         // loop.
         if (chainSource is _Future && (chainSource as _Future)._isComplete) {
           // propagate the value (simulating a tail call).
           listener._isChained = true;
@@ skipping 10 matching lines @@
         listener._setValue(listenerValueOrError);
       } else {
         listeners = listener._removeListeners();
         listener._setError(listenerValueOrError);
       }
       // Prepare for next round.
       source = listener;
     }
   }
 }