Renamed StreamSink to EventSink. Renamed signalError to addError.

sdk/lib/io/websocket_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;
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
@@ skipping 40 matching lines @@
   static const int FAILURE = 6;
 
   _WebSocketProtocolTransformer() {
     _prepareForNextFrame();
     _currentMessageType = _WebSocketMessageType.NONE;
   }
 
   /**
    * Process data received from the underlying communication channel.
    */
-  void handleData(List<int> buffer, StreamSink sink) {
+  void handleData(List<int> buffer, EventSink sink) {
     int count = buffer.length;
     int index = 0;
     int lastIndex = count;
     try {
       if (_state == CLOSED) {
         throw new WebSocketException("Data on closed connection");
       }
       if (_state == FAILURE) {
         throw new WebSocketException("Data on failed connection");
       }
@@ skipping 137 matching lines @@
             // Hack - as we always do index++ below.
             index--;
             break;
         }
 
         // Move to the next byte.
         index++;
       }
     } catch (e) {
       _state = FAILURE;
-      sink.signalError(e);
+      sink.addError(e);
     }
   }
 
-  void _lengthDone(StreamSink sink) {
+  void _lengthDone(EventSink sink) {
     if (_masked) {
       _state = MASK;
       _remainingMaskingKeyBytes = 4;
     } else {
       _remainingPayloadBytes = _len;
       _startPayload(sink);
     }
   }
 
-  void _maskDone(StreamSink sink) {
+  void _maskDone(EventSink sink) {
     _remainingPayloadBytes = _len;
     _startPayload(sink);
   }
 
-  void _startPayload(StreamSink sink) {
+  void _startPayload(EventSink sink) {
     // If there is no actual payload perform perform callbacks without
     // going through the PAYLOAD state.
     if (_remainingPayloadBytes == 0) {
       if (_isControlFrame()) {
         switch (_opcode) {
           case _WebSocketOpcode.CLOSE:
             _state = CLOSED;
             sink.close();
             break;
           case _WebSocketOpcode.PING:
             // TODO(ajohnsen): Handle ping.
             break;
           case _WebSocketOpcode.PONG:
             // TODO(ajohnsen): Handle pong.
             break;
         }
         _prepareForNextFrame();
       } else {
         _messageFrameEnd(sink);
       }
     } else {
       _state = PAYLOAD;
     }
   }
 
-  void _messageFrameEnd(StreamSink sink) {
+  void _messageFrameEnd(EventSink sink) {
     if (_fin) {
       switch (_currentMessageType) {
         case _WebSocketMessageType.TEXT:
           sink.add(_buffer.toString());
           break;
         case _WebSocketMessageType.BINARY:
           if (_buffer.length == 0) {
             sink.add(const []);
           } else {
             sink.add(_buffer.readBytes(_buffer.length));
           }
           break;
       }
       _buffer = null;
       _currentMessageType = _WebSocketMessageType.NONE;
     }
     _prepareForNextFrame();
   }
 
-  void _controlFrameEnd(StreamSink sink) {
+  void _controlFrameEnd(EventSink sink) {
     switch (_opcode) {
       case _WebSocketOpcode.CLOSE:
         closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
         if (_controlPayload.length > 0) {
           if (_controlPayload.length == 1) {
             throw new WebSocketException("Protocol error");
           }
           closeCode = _controlPayload[0] << 8 | _controlPayload[1];
           if (closeCode == WebSocketStatus.NO_STATUS_RECEIVED) {
             throw new WebSocketException("Protocol error");
@@ skipping 59 matching lines @@
 
 
 class _WebSocketTransformerImpl implements WebSocketTransformer {
   final StreamController<WebSocket> _controller =
       new StreamController<WebSocket>();
 
   Stream<WebSocket> bind(Stream<HttpRequest> stream) {
     stream.listen((request) {
         _upgrade(request)
             .then((WebSocket webSocket) => _controller.add(webSocket))
-            .catchError((error) => _controller.signalError(error));
+            .catchError((error) => _controller.addError(error));
     });
 
     return _controller.stream;
   }
 
   static Future<WebSocket> _upgrade(HttpRequest request) {
     var response = request.response;
     if (!_isUpgradeRequest(request)) {
       // Send error response and drain the request.
       request.listen((_) {}, onDone: () {
@@ skipping 134 matching lines @@
 
     bool closed = false;
     var transformer = new _WebSocketProtocolTransformer();
     _socket.transform(transformer).listen(
         (data) {
           _controller.add(data);
         },
         onError: (error) {
           if (closed) return;
           closed = true;
-          _controller.signalError(error);
+          _controller.addError(error);
           _controller.close();
         },
         onDone: () {
           if (closed) return;
           closed = true;
           if (_readyState == WebSocket.OPEN) {
             _readyState = WebSocket.CLOSING;
             if (transformer.closeCode != WebSocketStatus.NO_STATUS_RECEIVED) {
               _close(transformer.closeCode);
             } else {
               _close();
             }
             _readyState = WebSocket.CLOSED;
           }
           _closeCode = transformer.closeCode;
           _closeReason = transformer.closeReason;
           _controller.close();
           if (_writeClosed) _socket.destroy();
         },
         unsubscribeOnError: true);
 
     _socket.done
         .catchError((error) {
           if (closed) return;
           closed = true;
           _readyState = WebSocket.CLOSED;
           _closeCode = WebSocketStatus.ABNORMAL_CLOSURE;
-          _controller.signalError(error);
+          _controller.addError(error);
           _controller.close();
         })
         .whenComplete(() {
           _writeClosed = true;
         });
   }
 
   StreamSubscription listen(void onData(message),
                             {void onError(AsyncError error),
                              void onDone(),
@@ skipping 105 matching lines @@
       if (data != null) {
         _socket.add(data);
       }
     } catch (_) {
       // The socket can be closed before _socket.done have a chance
       // to complete.
       _writeClosed = true;
     }
   }
 }