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 201 matching lines @@
    *
    * This methods is called from [_StreamListener.pause()].
    * Subclasses can override this method, along with [isPaused] and
    * [createSubscription], if they want to do a different handling of paused
    * subscriptions, e.g., a filtering stream pausing its own source if all its
    * subscribers are paused.
    */
   void _pause(_StreamListener<T> listener, Signal resumeSignal) {
     assert(identical(listener._source, this));
     if (!listener._isSubscribed) {
-      throw new StateError("Subscription has been unsubscribed.");
+      throw new StateError("Subscription has been canceled.");
     }
     assert(!_isComplete);  // There can be no subscribers when complete.
     bool wasPaused = _isPaused;
     _incrementPauseCount(listener);
     if (resumeSignal != null) {
       resumeSignal.then(() { this._resume(listener, true); });
     }
     if (!wasPaused) {
       _onPauseStateChange();
     }
@@ skipping 24 matching lines @@
       void onError(AsyncError error),
       void onDone(),
       bool unsubscribeOnError);
 
   /**
    * Adds a listener to this stream.
    */
   void _addListener(_StreamSubscriptionImpl subscription);
 
   /**
-   * Handle an unsubscription requested from a [_StreamSubscriptionImpl].
+   * Handle a cancel 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.
+   * If an event is currently firing, the cancel is delayed
+   * until after the subscribers have received the event.
    */
-  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].
+   * Handle a cancel 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.
+   * If an event is currently firing, the cancel is delayed
+   * until after the subscriber has received the event.
    */
-  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 114 matching lines @@
   void _addListener(_StreamListener listener) {
     listener._setSubscribed(_currentEventIdBit);
     bool firstSubscriber = !_hasSubscribers;
     _InternalLinkList.add(this, listener);
     if (firstSubscriber) {
       _onSubscriptionStateChange();
     }
   }
 
   /**
-   * Handle an unsubscription requested from a [_StreamListener].
+   * Handle a cancel 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.
+   * If an event is currently firing, the cancel is delayed
+   * until after the subscribers have received the event.
    */
-  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;
   }
 }