Make _Future._chainForeignFuture not cause an assert.

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/*T|Future<T>*/ _FutureOnValue<S, T>(S value);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
@@ skipping 259 matching lines @@
     return result;
   }
 
   Stream<T> asStream() => new Stream<T>.fromFuture(this);
 
   void _setPendingComplete() {
     assert(_mayComplete);
     _state = _PENDING_COMPLETE;
   }
 
+  void _clearPendingComplete() {
+    assert(_isPendingComplete);
+    _state = _INCOMPLETE;
+  }
+
   AsyncError get _error {
     assert(_hasError);
     return _resultOrListeners;
   }
 
   _Future get _chainSource {
     assert(_isChained);
     return _resultOrListeners;
   }
 
@@ skipping 108 matching lines @@
   // in that case.
   static void _chainForeignFuture(Future source, _Future target) {
     assert(!target._isComplete);
     assert(source is! _Future);
 
     // Mark the target as chained (and as such half-completed).
     target._setPendingComplete();
     try {
       source.then((value) {
           assert(target._isPendingComplete);
-          target._completeWithValue(value);
+          // The "value" may be another future if the foreign future
+          // implementation is mis-behaving,
+          // so use _complete in stead of _completeWithValue.

[floitsch, 2016/05/10 15:39:51]

instead

[Lasse Reichstein Nielsen, 2016/05/11 10:19:36]

Done.

+          target._clearPendingComplete();  // Clear this first, it's set again.
+          target._complete(value);
         },
         // TODO(floitsch): eventually we would like to make this non-optional
         // and dependent on the listeners of the target future. If none of
         // the target future's listeners want to have the stack trace we don't
         // need a trace.
         onError: (error, [stackTrace]) {
           assert(target._isPendingComplete);
           target._completeError(error, stackTrace);
         });
     } catch (e, s) {
@@ skipping 224 matching lines @@
           } catch (e, s) {
             if (identical(source._error.error, e)) {
               listenerValueOrError = source._error;
             } else {
               listenerValueOrError = new AsyncError(e, s);
             }
             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 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) {
           Future chainSource = listenerValueOrError;
           // Shortcut if the chain-source is already completed. Just continue
           // the loop.
           _Future result = listener.result;
@@ skipping 52 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }