Rename unsubscribe to cancel.

sdk/lib/async/stream_impl.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;
 
 // States shared by single/multi stream implementations.
 
 /// Initial and default state where the stream can receive and send events.
 const int _STREAM_OPEN = 0;
@@ skipping 44 matching lines @@
    * If events are added to the stream (using [_add], [_signalError] or [_done])
    * while the stream is paused, or while another event is firing, events will
    * stored here.
    * Also supports scheduling the events for later execution.
    */
   _StreamImplEvents _pendingEvents;
 
   // ------------------------------------------------------------------
   // Stream interface.
 
-  StreamSubscription subscribe({void onData(T data),
-                                void onError(AsyncError error),
-                                void onDone(),
-                                bool unsubscribeOnError}) {
+  StreamSubscription listen(void onData(T data),
+                            { void onError(AsyncError error),
+                              void onDone(),
+                              bool unsubscribeOnError}) {
     if (_isComplete) {
       return new _DoneSubscription(onDone);
     }
     if (onData == null) onData = _nullDataHandler;
     if (onError == null) onError = _nullErrorHandler;
     if (onDone == null) onDone = _nullDoneHandler;
     unsubscribeOnError = identical(true, unsubscribeOnError);
     _StreamListener subscription =
         _createSubscription(onData, onError, onDone, unsubscribeOnError);
     _addListener(subscription);
@@ skipping 180 matching lines @@
       bool unsubscribeOnError);
 
   /**
    * Adds a listener to this stream.
    */
   void _addListener(_StreamSubscriptionImpl subscription);
 
   /**
    * Handle an unsubscription requested from a [_StreamSubscriptionImpl].
    *
-   * This method is called from [_StreamSubscriptionImpl.unsubscribe].
+   * This method is called from [_StreamSubscriptionImpl.cancel].
    *
    * If an event is currently firing, the subscription is delayed
    * until after the event has been sent to all subscribers.
    */
-  void _unsubscribe(_StreamSubscriptionImpl subscriber);
+  void _cancel(_StreamSubscriptionImpl subscriber);
 
   /**
    * Iterate over all current subscribers and perform an action on each.
    *
    * Subscribers added during the iteration will not be visited.
    * Subscribers unsubscribed during the iteration will only be removed
    * after they have been acted on.
    *
    * Any change in the pause state is only reported after all subscribers have
    * received the event.
@@ skipping 68 matching lines @@
    * Sends the "done" message directly to each subscriber.
    * This automatically stops further subscription and
    * unsubscribes all subscribers.
    */
   void _sendDone() {
     assert(!_isPaused);
     assert(_isClosed);
     _setComplete();
     if (!_hasSubscribers) return;
     _forEachSubscriber((subscriber) {
-      _unsubscribe(subscriber);
+      _cancel(subscriber);
       try {
         subscriber._sendDone();
       } catch (e, s) {
         new AsyncError(e, s).throwDelayed();
       }
     });
     assert(!_hasSubscribers);
     _onSubscriptionStateChange();
   }
 }
@@ skipping 57 matching lines @@
       throw new StateError("Stream has already subscriber.");
     }
     _subscriber = subscription;
     subscription._setSubscribed(0);
     _onSubscriptionStateChange();
     // TODO(floitsch): Should this be delayed?
     _handlePendingEvents();
   }
 
   /**
    * Handle an unsubscription requested from a [_StreamSubscriptionImpl].

[Lasse Reichstein Nielsen, 2013/01/04 08:17:55]

a cancel request.

[floitsch, 2013/01/04 15:51:36]

Done.

    *
-   * This method is called from [_StreamSubscriptionImpl.unsubscribe].
+   * This method is called from [_StreamSubscriptionImpl.cancel].
    *
    * If an event is currently firing, the subscription is delayed

[Lasse Reichstein Nielsen, 2013/01/04 08:17:55]

subscription (sic) -> cancel.
Perhaps also -> "... until after the subscriber has received the event". This is
actually what happens now.

[floitsch, 2013/01/04 15:51:36]

Done.

    * until after the event has been sent to all subscribers.
    */
-  void _unsubscribe(_StreamSubscriptionImpl subscriber) {
+  void _cancel(_StreamSubscriptionImpl subscriber) {
     assert(identical(subscriber._source, this));
     // We allow unsubscribing the currently firing subscription during
     // the event firing, because it is indistinguishable from delaying it since
     // that event has already received the event.
     if (!identical(_subscriber, subscriber)) {
       // You may unsubscribe more than once, only the first one counts.
       return;
     }
     _subscriber = null;
     int timesPaused = subscriber._setUnsubscribed();
@@ skipping 116 matching lines @@
     bool firstSubscriber = !_hasSubscribers;
     _InternalLinkList.add(this, listener);
     if (firstSubscriber) {
       _onSubscriptionStateChange();
     }
   }
 
   /**
    * Handle an unsubscription requested from a [_StreamListener].
    *
-   * This method is called from [_StreamListener.unsubscribe].
+   * This method is called from [_StreamListener.cancel].
    *
    * If an event is currently firing, the unsubscription is delayed
    * until after the event has been sent to all subscribers.
    */
-  void _unsubscribe(_StreamListener listener) {
+  void _cancel(_StreamListener listener) {
     assert(identical(listener._source, this));
     if (_InternalLink.isUnlinked(listener)) {
       // You may unsubscribe more than once, only the first one counts.
       return;
     }
     if (_isFiring) {
       if (listener._needsEvent(_currentEventIdBit)) {
         assert(listener._isSubscribed);
         listener._setPendingUnsubscribe();
       } else {
@@ skipping 65 matching lines @@
     if (handleDone == null) handleDone = _nullDoneHandler;
     _onDone = handleDone;
   }
 
   void _sendData(T data) {
     _onData(data);
   }
 
   void _sendError(AsyncError error) {
     _onError(error);
-    if (_unsubscribeOnError) _source._unsubscribe(this);
+    if (_unsubscribeOnError) _source._cancel(this);
   }
 
   void _sendDone() {
     _onDone();
   }
 
-  void unsubscribe() {
-    _source._unsubscribe(this);
+  void cancel() {
+    _source._cancel(this);
   }
 
   void pause([Signal resumeSignal]) {
     _source._pause(this, resumeSignal);
   }
 
   void resume() {
     if (!isPaused) {
       throw new StateError("Resuming unpaused subscription");
     }
@@ skipping 283 matching lines @@
   bool get _isComplete => _timer == null && _pauseCount == 0;
 
   void onData(void handleAction(T value)) {}
   void onError(void handleError(StateError error)) {}
   void onDone(void handleDone(T value)) {
     _handler = handleDone;
   }
 
   void pause([Signal signal]) {
     if (_isComplete) {
-      throw new StateError("Subscription has been unsubscribed.");
+      throw new StateError("Subscription has been canceled.");
     }
     if (_timer != null) _timer.cancel();
     _pauseCount++;
   }
 
   void resume() {
     if (_isComplete) {
-      throw new StateError("Subscription has been unsubscribed.");
+      throw new StateError("Subscription has been canceled.");
     }
     if (_pauseCount == 0) return;
     _pauseCount--;
     if (_pauseCount == 0) {
       _delayDone();
     }
   }
 
   bool get isPaused => _pauseCount > 0;
 
-  void unsubscribe() {
+  void cancel() {
     if (_isComplete) {
-      throw new StateError("Subscription has been unsubscribed.");
+      throw new StateError("Subscription has been canceled.");
     }
     if (_timer != null) {
       _timer.cancel();
       _timer = null;
     }
     _pauseCount = 0;
   }
 }