If transformException() returns a future, act like chain().

lib/coreimpl/future_implementation.dart

 // Copyright 2012 Google Inc. All Rights Reserved.
 // Dart core library.
 
 class FutureImpl<T> implements Future<T> {
 
   bool _isComplete = false;
 
   /**
    * Value that was provided to this Future by the Completer
    */
@@ skipping 154 matching lines @@
       throw new FutureAlreadyCompleteException();
     }
     _exception = exception;
     _stackTrace = stackTrace;
     _complete();
   }
 
   Future transform(Function transformation) {
     final completer = new Completer();
 
-    handleException((e) {
-      completer.completeException(e, stackTrace);
-      return true;
-    });
+    _forwardException(this, completer);
 
     then((v) {
       var transformed = null;
       try {
         transformed = transformation(v);
       } catch (e, stackTrace) {
         completer.completeException(e, stackTrace);
         return;
       }
       completer.complete(transformed);
     });
 
     return completer.future;
   }
 
   Future chain(Function transformation) {
     final completer = new Completer();
-    handleException((e) {
-      completer.completeException(e, this.stackTrace);
-      return true;
-    });
+
+    _forwardException(this, completer);
     then((v) {
       var future = null;
       try {
         future = transformation(v);
       } catch (ex, stackTrace) {
         completer.completeException(ex, stackTrace);
         return;
       }
-      future.handleException((e) {
-        completer.completeException(e, future.stackTrace);
-        return true;
-      });
-      future.then((b) => completer.complete(b));
+
+      _forward(future, completer);
     });
     return completer.future;
   }
 
   Future transformException(transformation(Object exception)) {
     final completer = new Completer();
 
     handleException((ex) {
       try {
-        completer.complete(transformation(ex));
+        final result = transformation(ex);
+
+        // If the transformation itself returns a future, then we will
+        // complete to what that completes to.
+        if (result is Future) {
+          _forward(result, completer);
+        } else {
+          completer.complete(result);
+        }
       } catch (innerException, stackTrace) {
         completer.completeException(innerException, stackTrace);
       }
       return true;
     });
 
     then(completer.complete);
 
     return completer.future;
   }
+
+  /**
+   * Forwards the success or error completion from [future] to [completer].
+   */
+  _forward(Future future, Completer completer) {
+    _forwardException(future, completer);
+    future.then(completer.complete);
+  }
+
+  /**
+   * Forwards the exception completion from [future] to [completer].
+   */
+  _forwardException(Future future, Completer completer) {
+    future.handleException((e) {
+      completer.completeException(e, future.stackTrace);
+      return true;
+    });
+  }
 }
 
 class CompleterImpl<T> implements Completer<T> {
 
   final FutureImpl<T> _futureImpl;
 
   CompleterImpl() : _futureImpl = new FutureImpl() {}
 
   Future<T> get future {
     return _futureImpl;
   }
 
   void complete(T value) {
     _futureImpl._setValue(value);
   }
 
   void completeException(Object exception, [Object stackTrace]) {
     _futureImpl._setException(exception, stackTrace);
   }
 }