Renamed StreamSink to EventSink. Renamed signalError to addError.

sdk/lib/async/stream_controller.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;
 
 // -------------------------------------------------------------------
 // Controller for creating and adding events to a stream.
 // -------------------------------------------------------------------
 
@@ skipping 28 matching lines @@
  * Whether to invoke a callback depends only on the state before and after
  * a stream action, for example firing an event. If the state changes multiple
  * times during the action, and then ends up in the same state as before, no
  * callback is performed.
  *
  * If listeners are added after the stream has completed (sent a "done" event),
  * the listeners will be sent a "done" event eventually, but they won't affect
  * the stream at all, and won't trigger callbacks. From the controller's point
  * of view, the stream is completely inert when has completed.
  */
-class StreamController<T> implements StreamSink<T> {
+class StreamController<T> implements EventSink<T> {
   final _StreamImpl<T> stream;
 
   /**
    * A controller with a broadcast [stream]..
    *
    * The [onPauseStateChange] function is called when the stream becomes
    * paused or resumes after being paused. The current pause state can
    * be read from [isPaused]. Ignored if [:null:].
    *
    * The [onSubscriptionStateChange] function is called when the stream
@@ skipping 18 matching lines @@
    * The [onSubscriptionStateChange] function is called when the stream
    * receives its first listener or loses its last. The current subscription
    * state can be read from [hasSubscribers]. Ignored if [:null:].
    */
   StreamController({void onPauseStateChange(),
                     void onSubscriptionStateChange()})
       : stream = new _SingleControllerStream<T>(onSubscriptionStateChange,
                                                 onPauseStateChange);
 
   /**
-   * Returns a view of this object that only exposes the [StreamSink] interface.
+   * Returns a view of this object that only exposes the [EventSink] interface.
    */
-  StreamSink<T> get sink => new StreamSinkView<T>(this);
+  EventSink<T> get sink => new EventSinkView<T>(this);
 
   /**
    * Whether the stream is closed for adding more events.
    *
    * If true, the "done" event might not have fired yet, but it has been
    * scheduled, and it is too late to add more events.
    */
   bool get isClosed => stream._isClosed;
 
   /** Whether one or more active subscribers have requested a pause. */
@@ skipping 12 matching lines @@
    *
    * If [error] is not an [AsyncError], [error] and an optional [stackTrace]
    * is combined into an [AsyncError] and sent this stream's listeners.
    *
    * Otherwise, if [error] is an [AsyncError], it is used directly as the
    * error object reported to listeners, and the [stackTrace] is ignored.
    *
    * If a subscription has requested to be unsubscribed on errors,
    * it will be unsubscribed after receiving this event.
    */
-  void signalError(Object error, [Object stackTrace]) {
+  void addError(Object error, [Object stackTrace]) {
     AsyncError asyncError;
     if (error is AsyncError) {
       asyncError = error;
     } else {
       asyncError = new AsyncError(error, stackTrace);
     }
-    stream._signalError(asyncError);
+    stream._addError(asyncError);
+  }
+
+  void signalError(Object error, [Object stackTrace]) {
+    addError(error, stackTrace);
   }
 
   /**
    * Send or enqueue a "done" message.
    *
    * The "done" message should be sent at most once by a stream, and it
    * should be the last message sent.
    */
   void close() { stream._close(); }
 }
@@ skipping 46 matching lines @@
   void _onPauseStateChange() {
     if (_pauseHandler != null) {
       try {
         _pauseHandler();
       } catch (e, s) {
         new AsyncError(e, s).throwDelayed();
       }
     }
   }
 }