Rename unsubscribeOnError to cancelOnError.

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.
 
 // Completion state of the stream.
 /// Initial and default state where the stream can receive and send events.
@@ skipping 61 matching lines @@
    * Also supports scheduling the events for later execution.
    */
   _PendingEvents _pendingEvents;
 
   // ------------------------------------------------------------------
   // Stream interface.
 
   StreamSubscription<T> listen(void onData(T data),
                                { void onError(AsyncError error),
                                  void onDone(),
-                                 bool unsubscribeOnError }) {
+                                 bool cancelOnError }) {
     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);
+    cancelOnError = identical(true, cancelOnError);
     _StreamSubscriptionImpl subscription =
-        _createSubscription(onData, onError, onDone, unsubscribeOnError);
+        _createSubscription(onData, onError, onDone, cancelOnError);
     _addListener(subscription);
     return subscription;
   }
 
   // ------------------------------------------------------------------
   // EventSink interface-like methods for sending events into the stream.
   // It's the responsibility of the caller to ensure that the stream is not
   // paused when adding events. If the stream is paused, the events will be
   // queued, but it's better to not send events at all.
 
@@ skipping 267 matching lines @@
   void _schedulePendingEvents() {
     assert(_hasPendingEvent);
     _pendingEvents.schedule(this);
   }
 
   /** Create a subscription object. Called by [subcribe]. */
   _StreamSubscriptionImpl<T> _createSubscription(
       void onData(T data),
       void onError(AsyncError error),
       void onDone(),
-      bool unsubscribeOnError);
+      bool cancelOnError);
 
   /**
    * Adds a listener to this stream.
    */
   void _addListener(_StreamSubscriptionImpl subscription);
 
   /**
    * Handle a cancel requested from a [_StreamSubscriptionImpl].
    *
    * This method is called from [_StreamSubscriptionImpl.cancel].
@@ skipping 197 matching lines @@
     _updatePauseCount(1);
   }
 
   /**
    * Create the new subscription object.
    */
   _StreamSubscriptionImpl<T> _createSubscription(
       void onData(T data),
       void onError(AsyncError error),
       void onDone(),
-      bool unsubscribeOnError) {
+      bool cancelOnError) {
     return new _StreamSubscriptionImpl<T>(
-        this, onData, onError, onDone, unsubscribeOnError);
+        this, onData, onError, onDone, cancelOnError);
   }
 
   void _addListener(_StreamListener subscription) {
     assert(!_isComplete);
     if (_hasListener) {
       throw new StateError("Stream already has subscriber.");
     }
     assert(_pauseCount == 1);
     _updatePauseCount(-1);
     _subscriber = subscription;
@@ skipping 97 matching lines @@
   /** Whether there are currently any subscribers on this [Stream]. */
   bool get _hasListener => !_InternalLinkList.isEmpty(this);
 
   /**
    * Create the new subscription object.
    */
   _StreamListener<T> _createSubscription(
       void onData(T data),
       void onError(AsyncError error),
       void onDone(),
-      bool unsubscribeOnError) {
+      bool cancelOnError) {
     return new _StreamSubscriptionImpl<T>(
-        this, onData, onError, onDone, unsubscribeOnError);
+        this, onData, onError, onDone, cancelOnError);
   }
 
   // -------------------------------------------------------------------
   // Internal implementation.
 
   /**
    * Iterate over all current subscribers and perform an action on each.
    *
    * The set of subscribers cannot be modified during this iteration.
    * All attempts to add or unsubscribe subscribers will be delayed until
@@ skipping 164 matching lines @@
  * [_StreamImpl.createSubscription].
  *
  * The subscription is in one of three states:
  * * Subscribed.
  * * Paused-and-subscribed.
  * * Unsubscribed.
  * Unsubscribing also resumes any pauses started by the subscription.
  */
 class _StreamSubscriptionImpl<T> extends _StreamListener<T>
                                  implements StreamSubscription<T> {
-  final bool _unsubscribeOnError;
+  final bool _cancelOnError;
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   var /* _DataHandler<T> */ _onData;
   _ErrorHandler _onError;
   _DoneHandler _onDone;
   _StreamSubscriptionImpl(_StreamImpl source,
                           this._onData,
                           this._onError,
                           this._onDone,
-                          this._unsubscribeOnError) : super(source);
+                          this._cancelOnError) : super(source);
 
   void onData(void handleData(T event)) {
     if (handleData == null) handleData = _nullDataHandler;
     _onData = handleData;
   }
 
   void onError(void handleError(AsyncError error)) {
     if (handleError == null) handleError = _nullErrorHandler;
     _onError = handleError;
   }
 
   void onDone(void handleDone()) {
     if (handleDone == null) handleDone = _nullDoneHandler;
     _onDone = handleDone;
   }
 
   void _sendData(T data) {
     _onData(data);
   }
 
   void _sendError(AsyncError error) {
     _onError(error);
-    if (_unsubscribeOnError) _source._cancel(this);
+    if (_cancelOnError) _source._cancel(this);
   }
 
   void _sendDone() {
     _onDone();
   }
 
   void cancel() {
     if (!_isSubscribed) return;
     _source._cancel(this);
   }
@@ skipping 408 matching lines @@
                                      onError: this._addError,
                                      onDone: this._close);
     } else {
       // TODO(lrn): Check why this can happen.
       if (_subscription == null) return;
       _subscription.cancel();
       _subscription = null;
     }
   }
 }