Revert "Handle the case of Stream.take(0) better." This reverts commit 8cead4090cc0b1184a2ad552003a…

sdk/lib/async/stream.dart

 // Copyright (c) 2013, 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 885 matching lines @@
    * that the future will complete with the first error on the stream and then
    * cancel the subscription.
    *
    * In case of a `done` event the future completes with the given
    * [futureValue].
    */
   Future/*<E>*/ drain/*<E>*/([/*=E*/ futureValue])
       => listen(null, cancelOnError: true).asFuture/*<E>*/(futureValue);
 
   /**
-   * Provides at most the first [count] data events of this stream.
+   * Provides at most the first [n] values of this stream.
    *
-   * Forwards all events of this stream to the returned stream
-   * until [count] data events have been forwarded or this stream ends,
-   * then ends the returned stream with a done event.
+   * Forwards the first [n] data events of this stream, and all error
+   * events, to the returned stream, and ends with a done event.
    *
-   * If this stream produces fewer than [count] data events before it's done,
+   * If this stream produces fewer than [count] values before it's done,
    * so will the returned stream.
    *
-   * Starts listening to this stream when the returned stream is listened to
-   * and stops listening when the first [count] data events have been received.
+   * Stops listening to the stream after the first [n] elements have been
+   * received.
    *
-   * This means that if this is a single-subscription (non-broadcast) streams
-   * it cannot be reused after the returned stream has been listened to.
+   * Internally the method cancels its subscription after these elements. This
+   * means that single-subscription (non-broadcast) streams are closed and
+   * cannot be reused after a call to this method.
    *
-   * If this is a broadcast stream, the returned stream is a broadcast stream.
-   * In that case, the events are only counted from the time
+   * The returned stream is a broadcast stream if this stream is.
+   * For a broadcast stream, the events are only counted from the time
    * the returned stream is listened to.
    */
   Stream<T> take(int count) {
     return new _TakeStream<T>(this, count);
   }
 
   /**
    * Forwards data events while [test] is successful.
    *
    * The returned stream provides the same events as this stream as long
-   * as [test] returns `true` for the event data. The stream is done
+   * as [test] returns [:true:] for the event data. The stream is done
    * when either this stream is done, or when this stream first provides
    * a value that [test] doesn't accept.
    *
    * Stops listening to the stream after the accepted elements.
    *
    * Internally the method cancels its subscription after these elements. This
    * means that single-subscription (non-broadcast) streams are closed and
    * cannot be reused after a call to this method.
    *
    * The returned stream is a broadcast stream if this stream is.
@@ skipping 883 matching lines @@
 class _ControllerEventSinkWrapper<T> implements EventSink<T> {
   EventSink _sink;
   _ControllerEventSinkWrapper(this._sink);
 
   void add(T data) { _sink.add(data); }
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
   void close() { _sink.close(); }
 }