Remove StreamSink(replaced by EventSink) and make IOSink extend EventSink.

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 903 matching lines @@
   void pause([Future resumeSignal]);
 
   /**
    * Resume after a pause.
    */
   void resume();
 }
 
 
 /**
- * *Deprecated*. Use [EventSink] instead.
- */
-abstract class StreamSink<T> extends EventSink<T>{
-  /* TODO(8997): Remove class.*/
-  /** *Deprecated*. Use [EventSink.addError] instead.*/
-  void signalError(AsyncError errorEvent) { addError(errorEvent); }
-}
-
-
-/**
  * An interface that abstracts creation or handling of [Stream] events.
  */
 abstract class EventSink<T> {
   /** Create a data event */
   void add(T event);
   /** Create an async error. */
   void addError(AsyncError errorEvent);
   /** Request a stream to close. */
-  void close();
+  close();

[floitsch, 2013/04/11 12:45:01]

keep.
The EventSink.close should be assumed not to return anything on 'close'.

[Anders Johnsen, 2013/04/11 12:53:05]

Done.

 }
 
 
 /** [Stream] wrapper that only exposes the [Stream] interface. */
 class StreamView<T> extends Stream<T> {
   Stream<T> _stream;
 
   StreamView(this._stream);
 
   bool get isBroadcast => _stream.isBroadcast;
 
   Stream<T> asBroadcastStream() => _stream.asBroadcastStream();
 
   StreamSubscription<T> listen(void onData(T value),
                                { void onError(AsyncError error),
                                  void onDone(),
                                  bool unsubscribeOnError }) {
     return _stream.listen(onData, onError: onError, onDone: onDone,
                           unsubscribeOnError: unsubscribeOnError);
   }
 }
 
 /**
  * [EventSink] wrapper that only exposes the [EventSink] interface.
  */
-class EventSinkView<T> extends StreamSink<T> {
+class EventSinkView<T> extends EventSink<T> {
   // TODO(8997): Implment EventSink instead.
   final EventSink<T> _sink;
 
   EventSinkView(this._sink);
 
   void add(T value) { _sink.add(value); }
   void addError(AsyncError error) { _sink.addError(error); }
   void close() { _sink.close(); }
 }
 
@@ skipping 239 matching lines @@
     if (_isClosed) throw new StateError("Already closed.");
     _isClosed = true;
     if (_isSubscribed) {
       _subscription.cancel();
       _subscription = null;
     }
     _onDone();
   }
 }
 
 /* TODO(8997): Implement EventSink instead, */

[floitsch, 2013/04/11 12:45:01]

Remove TODO.

[Anders Johnsen, 2013/04/11 12:53:05]

Done.

-class _EventOutputSinkWrapper<T> extends StreamSink<T> {
+class _EventOutputSinkWrapper<T> extends EventSink<T> {
   _EventOutputSink _sink;
   _EventOutputSinkWrapper(this._sink);
 
   void add(T data) { _sink._sendData(data); }
   void addError(AsyncError error) { _sink._sendError(error); }
   void close() { _sink._sendDone(); }
 }