Keep track of closing socket, in WebSocket, so we don't write once the socket is closed.

sdk/lib/io/websocket_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.io;
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
@@ skipping 415 matching lines @@
 
 
 class _WebSocketImpl extends Stream<Event> implements WebSocket {
   final StreamController<Event> _controller = new StreamController<Event>();
 
   final _WebSocketProtocolProcessor _processor =
       new _WebSocketProtocolProcessor();
 
   final Socket _socket;
   int _readyState = WebSocket.CONNECTING;
+  bool _writeClosed = false;
 
   static final HttpClient _httpClient = new HttpClient();
 
   static Future<WebSocket> connect(String url, [protocols]) {
     Uri uri = Uri.parse(url);
     if (uri.scheme != "ws" && uri.scheme != "wss") {
       throw new WebSocketException("Unsupported URL scheme '${uri.scheme}'");
     }
     if (uri.userInfo != "") {
       throw new WebSocketException("Unsupported user info '${uri.userInfo}'");
@@ skipping 92 matching lines @@
       if (_readyState == WebSocket.OPEN) {
         _readyState = WebSocket.CLOSING;
         if (code != WebSocketStatus.NO_STATUS_RECEIVED) {
           _close(code);
         } else {
           _close();
           clean = false;
         }
         _readyState = WebSocket.CLOSED;
       }
+      if (_readyState == WebSocket.CLOSED) return;
       _controller.add(new _WebSocketCloseEvent(clean, code, reason));
       _controller.close();
     };
 
     _socket.listen(
         (data) => _processor.update(data, 0, data.length),
         onDone: () => _processor.closed(),
         onError: (error) => _controller.signalError(error));
+
+    _socket.done
+        .catchError((error) {
+          if (_readyState == WebSocket.CLOSED) return;
+          _readyState = WebSocket.CLOSED;
+          _controller.signalError(error);
+          _controller.close();
+          _processor.closed();

[Søren Gjesse, 2013/02/28 17:15:24]

As discussed offline there should probably be a _socket.destroy() here as well.

[Anders Johnsen, 2013/02/28 17:19:47]

Done.

+        })
+        .whenComplete(() {
+          _writeClosed = true;
+        });
   }
 
   StreamSubscription<Event> listen(void onData(Event event),
                                    {void onError(AsyncError error),
                                     void onDone(),
                                     bool unsubscribeOnError}) {
     return _controller.stream.listen(onData,
                                      onError: onError,
                                      onDone: onDone,
                                      unsubscribeOnError: unsubscribeOnError);
@@ skipping 58 matching lines @@
         opcode = _WebSocketOpcode.BINARY;
         data = message;
       }
     } else {
       opcode = _WebSocketOpcode.TEXT;
     }
     _sendFrame(opcode, data);
   }
 
   void _sendFrame(int opcode, [List<int> data]) {
+    if (_writeClosed) return;
     bool mask = false;  // Masking not implemented for server.
     int dataLength = data == null ? 0 : data.length;
     // Determine the header size.
     int headerSize = (mask) ? 6 : 2;
     if (dataLength > 65535) {
       headerSize += 8;
     } else if (dataLength > 125) {
       headerSize += 2;
     }
     List<int> header = new List<int>(headerSize);
@@ skipping 32 matching lines @@
 
 class _WebSocketCloseEvent implements CloseEvent {
   _WebSocketCloseEvent(this._wasClean, this._code, this._reason);
   bool get wasClean => _wasClean;
   int get code => _code;
   String get reason => _reason;
   bool _wasClean;
   int _code;
   String _reason;
 }