Rename unsubscribeOnError to cancelOnError.

sdk/lib/async/stream_pipe.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;
 
 /** Utility function to create an [AsyncError] if [error] isn't one already. */
 AsyncError _asyncError(Object error, Object stackTrace, [AsyncError cause]) {
   if (error is AsyncError) return error;
   if (cause == null) return new AsyncError(error, stackTrace);
@@ skipping 40 matching lines @@
 abstract class _ForwardingStream<S, T> extends Stream<T> {
   final Stream<S> _source;
 
   _ForwardingStream(this._source);
 
   bool get isBroadcast => _source.isBroadcast;
 
   StreamSubscription<T> listen(void onData(T value),
                               { void onError(AsyncError error),
                                 void onDone(),
-                                bool unsubscribeOnError }) {
+                                bool cancelOnError }) {
     if (onData == null) onData = _nullDataHandler;
     if (onError == null) onError = _nullErrorHandler;
     if (onDone == null) onDone = _nullDoneHandler;
-    unsubscribeOnError = identical(true, unsubscribeOnError);
-    return _createSubscription(onData, onError, onDone, unsubscribeOnError);
+    cancelOnError = identical(true, cancelOnError);
+    return _createSubscription(onData, onError, onDone, cancelOnError);
   }
 
   StreamSubscription<T> _createSubscription(void onData(T value),
                                             void onError(AsyncError error),
                                             void onDone(),
-                                            bool unsubscribeOnError) {
+                                            bool cancelOnError) {
     return new _ForwardingStreamSubscription<S, T>(
-        this, onData, onError, onDone, unsubscribeOnError);
+        this, onData, onError, onDone, cancelOnError);
   }
 
   // Override the following methods in subclasses to change the behavior.
 
   void _handleData(S data, _EventOutputSink<T> sink) {
     var outputData = data;
     sink._sendData(outputData);
   }
 
   void _handleError(AsyncError error, _EventOutputSink<T> sink) {
@@ skipping 61 matching lines @@
   }
 }
 
 
 /**
  * Abstract superclass for subscriptions that forward to other subscriptions.
  */
 class _ForwardingStreamSubscription<S, T>
     extends _BaseStreamSubscription<T> implements _EventOutputSink<T> {
   final _ForwardingStream<S, T> _stream;
-  final bool _unsubscribeOnError;
+  final bool _cancelOnError;
 
   StreamSubscription<S> _subscription;
 
   _ForwardingStreamSubscription(this._stream,
                                 void onData(T data),
                                 void onError(AsyncError error),
                                 void onDone(),
-                                this._unsubscribeOnError)
+                                this._cancelOnError)
       : super(onData, onError, onDone) {
     // Don't unsubscribe on incoming error, only if we send an error forwards.
     _subscription =
         _stream._source.listen(_handleData,
                                onError: _handleError,
                                onDone: _handleDone);
   }
 
   // StreamSubscription interface.
 
@@ skipping 15 matching lines @@
   }
 
   // _EventOutputSink interface. Sends data to this subscription.
 
   void _sendData(T data) {
     _onData(data);
   }
 
   void _sendError(AsyncError error) {
     _onError(error);
-    if (_unsubscribeOnError) {
+    if (_cancelOnError) {
       _subscription.cancel();
       _subscription = null;
     }
   }
 
   void _sendDone() {
     // If the transformation sends a done signal, we stop the subscription.
     if (_subscription != null) {
       _subscription.cancel();
       _subscription = null;
@@ skipping 317 matching lines @@
 
   void handleError(AsyncError error, EventSink<T> sink) {
     _handleError(error, sink);
   }
 
   void handleDone(EventSink<T> sink) {
     _handleDone(sink);
   }
 }