Renamed StreamSink to EventSink. Renamed signalError to addError.

sdk/lib/io/http_impl.dart

 // Copyright (c) 2013, 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.io;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 678 matching lines @@
     writeCRLF();
   }
 }
 
 
 // Transformer that transforms data to HTTP Chunked Encoding.
 class _ChunkedTransformer extends StreamEventTransformer<List<int>, List<int>> {
   final bool writeEnd;
   _ChunkedTransformer({this.writeEnd: true});
 
-  void handleData(List<int> data, StreamSink<List<int>> sink) {
+  void handleData(List<int> data, EventSink<List<int>> sink) {
     _addChunk(data, sink.add);
   }
 
-  void handleDone(StreamSink<List<int>> sink) {
+  void handleDone(EventSink<List<int>> sink) {
     if (writeEnd) {
       _addChunk([], sink.add);
     }
     sink.close();
   }
 
   static void _addChunk(List<int> data, void add(List<int> data)) {
     add(_chunkHeader(data.length));
     if (data.length > 0) add(data);
     add(_chunkFooter);
@@ skipping 25 matching lines @@
 class _DoneTransformer implements StreamTransformer<List<int>, List<int>> {
   final StreamController<List<int>> _controller
       = new StreamController<List<int>>();
   final Function _onDone;
 
   _DoneTransformer(this._onDone);
 
   Stream<List<int>> bind(Stream<List<int>> stream) {
     var subscription = stream.listen(
         _controller.add,
-        onError: _controller.signalError,
+        onError: _controller.addError,
         onDone: () {
           _onDone();
           _controller.close();
         });
     return _controller.stream;
   }
 }
 
 // Transformer that validates the data written.
 class _DataValidatorTransformer
     implements StreamTransformer<List<int>, List<int>> {
   final StreamController<List<int>> _controller =
       new StreamController<List<int>>();
   int _bytesWritten = 0;
 
   int expectedTransferLength;
 
   Stream<List<int>> bind(Stream<List<int>> stream) {
     var subscription;
     subscription = stream.listen(
         (data) {
           if (expectedTransferLength != null) {
             _bytesWritten += data.length;
             if (_bytesWritten > expectedTransferLength) {
               subscription.cancel();
-              _controller.signalError(new HttpException(
+              _controller.addError(new HttpException(
                   "Content size exceeds specified contentLength. "
                   "$_bytesWritten bytes written while expected "
                   "$expectedTransferLength."));
               _controller.close();
               return;
             }
           }
           _controller.add(data);
         },
         onError: (error) {
-          _controller.signalError(error);
+          _controller.addError(error);
           _controller.close();
         },
         onDone: () {
           if (expectedTransferLength != null) {
             if (_bytesWritten < expectedTransferLength) {
-              _controller.signalError(new HttpException(
+              _controller.addError(new HttpException(
                   "Content size below specified contentLength. "
                   " $_bytesWritten bytes written while expected "
                   "$expectedTransferLength."));
             }
           }
           _controller.close();
         },
         unsubscribeOnError: true);
     return _controller.stream;
   }
@@ skipping 520 matching lines @@
   StreamSubscription<HttpRequest> listen(void onData(HttpRequest event),
                                          {void onError(AsyncError error),
                                          void onDone(),
                                          bool unsubscribeOnError}) {
     _serverSocket.listen(
         (Socket socket) {
           // Accept the client connection.
           _HttpConnection connection = new _HttpConnection(socket, this);
           _connections.add(connection);
         },
-        onError: _controller.signalError,
+        onError: _controller.addError,
         onDone: _controller.close);
     return _controller.stream.listen(onData,
                                      onError: onError,
                                      onDone: onDone,
                                      unsubscribeOnError: unsubscribeOnError);
   }
 
   void close() {
     closed = true;
     if (_serverSocket != null && _closeServer) {
@@ skipping 16 matching lines @@
 
   set sessionTimeout(int timeout) {
     _sessionManager.sessionTimeout = timeout;
   }
 
   void _handleRequest(HttpRequest request) {
     _controller.add(request);
   }
 
   void _handleError(AsyncError error) {
-    if (!closed) _controller.signalError(error);
+    if (!closed) _controller.addError(error);
   }
 
   void _connectionClosed(_HttpConnection connection) {
     _connections.remove(connection);
   }
 
   _HttpSessionManager get _sessionManager {
     // Lazy init.
     if (_sessionManagerInstance == null) {
       _sessionManagerInstance = new _HttpSessionManager();
@@ skipping 255 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }