Remove Signal class and use Future/.whenComplete instead.

sdk/lib/async/stream.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;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 135 matching lines @@
         completer.completeError(e.error, e.stackTrace);
       },
       onDone: () {
         completer.complete(value);
       },
       unsubscribeOnError: true);
     return completer.future;
   }
 
   // Deprecated method, previously called 'pipe', retained for compatibility.
-  Signal pipeInto(Sink<T> sink,
+  Future pipeInto(Sink<T> sink,
                   {void onError(AsyncError error),
                    bool unsubscribeOnError}) {
-    SignalCompleter completer = new SignalCompleter();
+    Completer completer = new Completer();
     this.listen(
         sink.add,
         onError: onError,
         onDone: () {
           sink.close();
-          completer.complete();
+          completer.complete(null);
         },
         unsubscribeOnError: unsubscribeOnError);
-    return completer.signal;
+    return completer.future;
   }
 
 
   /**
    * Check whether [match] occurs in the elements provided by this stream.
    *
    * Completes the [Future] when the answer is known.
    * If this stream reports an error, the [Future] will report that error.
    */
   Future<bool> contains(T match) {
@@ skipping 530 matching lines @@
   /** Set or override the error event handler of this subscription. */
   void onError(void handleError(AsyncError error));
 
   /** Set or override the done event handler of this subscription. */
   void onDone(void handleDone());
 
   /**
    * Request that the stream pauses events until further notice.
    *
    * If [resumeSignal] is provided, the stream will undo the pause
-   * when the signal completes.
+   * when the future completes in any way.
    * A call to [resume] will also undo a pause.
    *
    * If the subscription is paused more than once, an equal number
    * of resumes must be performed to resume the stream.
    */
-  void pause([Signal resumeSignal]);
+  void pause([Future resumeSignal]);
 
   /**
    * Resume after a pause.
    */
   void resume();
 }
 
 
 /**
  * An interface that abstracts sending events into a [Stream].
@@ skipping 97 matching lines @@
     sink.signalError(error);
   }
 
   /**
    * Handle an incoming done event.
    */
   void handleDone(StreamSink<T> sink) {
     sink.close();
   }
 }