internal void _addListener(_FutureListener listener) { D.assert(listener._nextListener == null); if (_mayAddListener) { listener._nextListener = (_FutureListener)_resultOrListeners; _resultOrListeners = listener; } else { if (_isChained) { // Delegate listeners to chained source future. // If the source is complete, instead copy its values and // drop the chaining. _Future source = _chainSource; if (!source._isComplete) { source._addListener(listener); return; } _cloneResult(source); } D.assert(_isComplete); // Handle late listeners asynchronously. _zone.scheduleMicrotask(() => { _propagateToListeners(this, listener); return(null); }); } }
internal void _completeError(Exception error) { D.assert(!_isComplete); _FutureListener listeners = _removeListeners(); _setError(error); _propagateToListeners(this, listeners); }
internal void _completeWithValue(object value) { D.assert(!_isComplete); _FutureListener listeners = _removeListeners(); _setValue(value); _propagateToListeners(this, listeners); }
_FutureListener _removeListeners() { // Reverse listeners before returning them, so the resulting list is in // subscription order. D.assert(!_isComplete); _FutureListener current = (_FutureListener)_resultOrListeners; _resultOrListeners = null; return(_reverseListeners(current)); }
_FutureListener _reverseListeners(_FutureListener listeners) { _FutureListener prev = null; _FutureListener current = listeners; while (current != null) { _FutureListener next = current._nextListener; current._nextListener = prev; prev = current; current = next; } return(prev); }
void _prependListeners(_FutureListener listeners) { if (listeners == null) { return; } if (_mayAddListener) { _FutureListener existingListeners = (_FutureListener)_resultOrListeners; _resultOrListeners = listeners; if (existingListeners != null) { _FutureListener cursor = listeners; while (cursor._nextListener != null) { cursor = cursor._nextListener; } cursor._nextListener = existingListeners; } } else { if (_isChained) { // Delegate listeners to chained source future. // If the source is complete, instead copy its values and // drop the chaining. _Future source = _chainSource; if (!source._isComplete) { source._prependListeners(listeners); return; } _cloneResult(source); } D.assert(_isComplete); listeners = _reverseListeners(listeners); _zone.scheduleMicrotask(() => { _propagateToListeners(this, listeners); return(null); }); } }
internal void _complete(FutureOr value = default) { D.assert(!_isComplete); if (value.isFuture) { if (value.f is _Future coreFuture) { _chainCoreFuture(coreFuture, this); } else { _chainForeignFuture(value.f, this); } } else { _FutureListener listeners = _removeListeners(); _setValue(value.v); _propagateToListeners(this, listeners); } }
static void _chainCoreFuture(_Future source, _Future target) { D.assert(target._mayAddListener); // Not completed, not already chained. while (source._isChained) { source = source._chainSource; } if (source._isComplete) { _FutureListener listeners = target._removeListeners(); target._cloneResult(source); _propagateToListeners(target, listeners); } else { _FutureListener listeners = (_FutureListener)target._resultOrListeners; target._setChained(source); source._prependListeners(listeners); } }
static void _propagateToListeners(_Future source, _FutureListener listeners) { while (true) { D.assert(source._isComplete); bool hasError = source._hasError; if (listeners == null) { if (hasError) { AsyncError asyncError = source._error; source._zone.handleUncaughtError(asyncError); } return; } // Usually futures only have one listener. If they have several, we // call handle them separately in recursive calls, continuing // here only when there is only one listener left. while (listeners._nextListener != null) { _FutureListener currentListener = listeners; listeners = currentListener._nextListener; currentListener._nextListener = null; _propagateToListeners(source, currentListener); } _FutureListener listener = listeners; var sourceResult = source._resultOrListeners; // Do the actual propagation. // Set initial state of listenerHasError and listenerValueOrError. These // variables are updated with the outcome of potential callbacks. // Non-error results, including futures, are stored in // listenerValueOrError and listenerHasError is set to false. Errors // are stored in listenerValueOrError as an [AsyncError] and // listenerHasError is set to true. bool listenerHasError = hasError; var listenerValueOrError = sourceResult; // Only if we either have an error or callbacks, go into this, somewhat // expensive, branch. Here we'll enter/leave the zone. Many futures // don't have callbacks, so this is a significant optimization. if (hasError || listener.handlesValue || listener.handlesComplete) { Zone zone = listener._zone; if (hasError && !source._zone.inSameErrorZone(zone)) { // Don't cross zone boundaries with errors. AsyncError asyncError = source._error; source._zone.handleUncaughtError(asyncError); return; } Zone oldZone = null; if (!ReferenceEquals(Zone.current, zone)) { // Change zone if it's not current. oldZone = Zone._enter(zone); } // These callbacks are abstracted to isolate the try/catch blocks // from the rest of the code to work around a V8 glass jaw. Action handleWhenCompleteCallback = () => { // The whenComplete-handler is not combined with normal value/error // handling. This means at most one handleX method is called per // listener. D.assert(!listener.handlesValue); D.assert(!listener.handlesError); FutureOr completeResult; try { completeResult = listener.handleWhenComplete(); } catch (Exception e) { if (hasError && ReferenceEquals(source._error.InnerException, e)) { listenerValueOrError = source._error; } else { listenerValueOrError = new AsyncError(e); } listenerHasError = true; return; } if (completeResult.isFuture) { var completeResultFuture = completeResult.f; if (completeResultFuture is _Future completeResultCoreFuture && completeResultCoreFuture._isComplete) { if (completeResultCoreFuture._hasError) { listenerValueOrError = completeResultCoreFuture._error; listenerHasError = true; } // Otherwise use the existing result of source. return; } // We have to wait for the completeResult future to complete // before knowing if it's an error or we should use the result // of source. var originalSource = source; listenerValueOrError = completeResultFuture.then((_) => FutureOr.future(originalSource)); listenerHasError = false; } }; Action handleValueCallback = () => { try { listenerValueOrError = listener.handleValue(sourceResult); } catch (Exception e) { listenerValueOrError = new AsyncError(e); listenerHasError = true; } }; Action handleError = () => { try { AsyncError asyncError = source._error; if (listener.matchesErrorTest(asyncError) && listener.hasErrorCallback) { listenerValueOrError = listener.handleError(asyncError); listenerHasError = false; } } catch (Exception e) { if (ReferenceEquals(source._error.InnerException, e)) { listenerValueOrError = source._error; } else { listenerValueOrError = new AsyncError(e); } listenerHasError = true; } }; if (listener.handlesComplete) { handleWhenCompleteCallback(); } else if (!hasError) { if (listener.handlesValue) { handleValueCallback(); } } else { if (listener.handlesError) { handleError(); } } // If we changed zone, oldZone will not be null. if (oldZone != null) { Zone._leave(oldZone); } if (listenerValueOrError is FutureOr futureOr) { listenerValueOrError = futureOr.isFuture ? futureOr.f : futureOr.v; } // If the listener's value is a future we need to chain it. Note that // this can only happen if there is a callback. if (listenerValueOrError is Future chainSource) { // Shortcut if the chain-source is already completed. Just continue // the loop. _Future listenerResult = listener.result; if (chainSource is _Future chainSourceCore) { if (chainSourceCore._isComplete) { listeners = listenerResult._removeListeners(); listenerResult._cloneResult(chainSourceCore); source = chainSourceCore; continue; } else { _chainCoreFuture(chainSourceCore, listenerResult); } } else { _chainForeignFuture(chainSource, listenerResult); } return; } } _Future result = listener.result; listeners = result._removeListeners(); if (!listenerHasError) { result._setValue(listenerValueOrError); } else { AsyncError asyncError = (AsyncError)listenerValueOrError; result._setErrorObject(asyncError); } // Prepare for next round. source = result; } }