Use onClosed instead of onError in the WebSocket classes.

runtime/bin/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.
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
   static const int BINARY = 1;
   static const int TEXT = 2;
@@ skipping 199 matching lines @@
               }
             }
 
             // Hack - as we always do index++ below.
             index--;
         }
 
         // Move to the next byte.
         index++;
       }
-    } catch (e) {
-      _reportError(e);
+    } catch (e, s) {

[Søren Gjesse, 2012/09/04 07:17:10]

Are you using s?

[Anders Johnsen, 2012/09/04 07:21:27]

I did (bug hunt) but removing.

+      if (onClosed !== null) onClosed(1006, "Protocol error");
+      _state = FAILURE;
     }
   }
 
   /**
    * Indicate that the underlying communication channel has been closed.
    */
   void closed() {
     if (_state == START || _state == CLOSED || _state == FAILURE) return;
-    _reportError(new WebSocketException("Protocol error $_state"));
+    if (onClosed !== null) onClosed(1006, "Connection closed unexpectedly");
     _state = CLOSED;
   }
 
   void _lengthDone() {
     if (_masked) {
       _state = MASK;
       _remainingMaskingKeyBytes = 4;
     } else {
       _remainingPayloadBytes = _len;
       _startPayload();
     }
   }
 
   void _maskDone() {
     _remainingPayloadBytes = _len;
     _startPayload();
   }
 
   void _startPayload() {
     // 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:
-            if (onClosed != null) onClosed(null, null);
+            if (onClosed != null) onClosed(1005, "");
             _state = CLOSED;
             break;
           case _WebSocketOpcode.PING:
             if (onPing != null) onPing(null);
             break;
           case _WebSocketOpcode.PONG:
             if (onPong != null) onPong(null);
             break;
         }
         _prepareForNextFrame();
       } else {
         _messageFrameEnd();
       }
     } else {
       _state = PAYLOAD;
     }
   }
 
   void _messageFrameEnd() {
     if (_fin) {
       if (onMessageEnd != null) onMessageEnd();
       _currentMessageType = _WebSocketMessageType.NONE;
     }
     _prepareForNextFrame();
   }
 
   void _controlFrameEnd() {
     switch (_opcode) {
       case _WebSocketOpcode.CLOSE:
-        int status;
-        String reason;
+        int status = 1005;
+        String reason = "";
         if (_controlPayload.length > 0) {
           if (_controlPayload.length == 1) {
             throw new WebSocketException("Protocol error");
           }
           status = _controlPayload[0] << 8 | _controlPayload[1];
           if (_controlPayload.length > 2) {
             var decoder = _StringDecoders.decoder(Encoding.UTF_8);
             decoder.write(
                 _controlPayload.getRange(2, _controlPayload.length - 2));
             reason = decoder.decoded;
@@ skipping 27 matching lines @@
     _len = null;
     _masked = null;
     _maskingKey = 0;
     _remainingLenBytes = null;
     _remainingMaskingKeyBytes = null;
     _remainingPayloadBytes = null;
     _unmaskingIndex = 0;
     _controlPayload = null;
   }
 
-  void _reportError(e) {
-    // Report the error through the error callback if any. Otherwise
-    // throw the error.
-    if (onError != null) {
-      onError(e);
-      _state = FAILURE;
-    } else {
-      throw e;
-    }
-  }
-
   int _state;
   bool _fin;
   int _opcode;
   int _len;
   bool _masked;
   int _maskingKey;
   int _remainingLenBytes;
   int _remainingMaskingKeyBytes;
   int _remainingPayloadBytes;
   int _unmaskingIndex;
 
   int _currentMessageType;
   List<int> _controlPayload;
 
   Function onMessageStart;
   Function onMessageData;
   Function onMessageEnd;
   Function onPing;
   Function onPong;
   Function onClosed;
-  Function onError;
 }
 
 
 class _WebSocketConnectionBase  {
   void _socketConnected(Socket socket) {
     _socket = socket;
-    _socket.onError = (e) {
-      _reportError(e);
-      _socket.close();
-    };
+    _socket.onError = (e) => _socket.close();
   }
 
   void _startProcessing(List<int> unparsedData) {
     _WebSocketProtocolProcessor processor = new _WebSocketProtocolProcessor();
     processor.onMessageStart = _onWebSocketMessageStart;
     processor.onMessageData = _onWebSocketMessageData;
     processor.onMessageEnd = _onWebSocketMessageEnd;
     processor.onPing = _onWebSocketPing;
     processor.onPong = _onWebSocketPong;
     processor.onClosed = _onWebSocketClosed;
-    processor.onError = _onWebSocketError;
     if (unparsedData != null) {
       processor.update(unparsedData, 0, unparsedData.length);
     }
     _socket.onData = () {
       int available = _socket.available();
       List<int> data = new List<int>(available);
       int read = _socket.readList(data, 0, available);
       processor.update(data, 0, read);
     };
     _socket.onClosed = () {
       processor.closed();
       if (_closeSent) {
         // Got socket close in response to close frame. Don't treat
         // that as an error.
         if (_closeTimer != null) _closeTimer.cancel();
       } else {
-        _reportError(new WebSocketException("Unexpected close"));
+        if (_onClosed !== null) _onClosed(1006, "Unexpected close");
       }
       _socket.close();
     };
   }
 
   void set onMessage(void callback(Object message)) {
     _onMessage = callback;
   }
 
   void set onClosed(void callback(int status, String reason)) {
     _onClosed = callback;
   }
 
-  void set onError(void callback(e)) {
-    _onError = callback;
-  }
-
   send(message) {
     if (_closeSent) {
       throw new WebSocketException("Connection closed");
     }
     List<int> data;
     int opcode;
     if (message != null) {
       if (message is String) {
         opcode = _WebSocketOpcode.TEXT;
         data = _StringEncoders.encoder(Encoding.UTF_8).encodeString(message);
@@ skipping 91 matching lines @@
     if (_onClosed != null) _onClosed(status, reason);
     if (_closeSent) {
       // Got close frame in response to close frame. Now close the socket.
       if (_closeTimer != null) _closeTimer.cancel();
       _socket.close();
     } else {
       close(status);
     }
   }
 
-  _onWebSocketError(e) {
-    _reportError(e);
-    _socket.close();
-  }
-
   _sendFrame(int opcode, [List<int> data]) {
     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;
     }
@@ skipping 15 matching lines @@
     for (int i = 0; i < lengthBytes; i++) {
       header[index++] = dataLength >> (((lengthBytes - 1) - i) * 8) & 0xFF;
     }
     assert(index == headerSize);
     _socket.outputStream.write(header);
     if (data != null) {
       _socket.outputStream.write(data);
     }
   }
 
-  void _reportError(e) {
-    if (_onError != null) {
-      _onError(e);
-    } else {
-      throw e;
-    }
-  }
-
   Socket _socket;
   Timer _closeTimer;
   int _hash;
 
   Function _onMessage;
   Function _onClosed;
-  Function _onError;
 
   int _currentMessageType = _WebSocketMessageType.NONE;
   _StringDecoder _decoder;
   ListOutputStream _outputStream;
   bool _closeReceived = false;
   bool _closeSent = false;
 }
 
 
 class _WebSocketConnection
@@ skipping 66 matching lines @@
   Function _onOpen;
 }
 
 
 class _WebSocketClientConnection
     extends _WebSocketConnectionBase implements WebSocketClientConnection {
   _WebSocketClientConnection(HttpClientConnection this._conn,
                              [List<String> protocols]) {
     _conn.onRequest = _onHttpClientRequest;
     _conn.onResponse = _onHttpClientResponse;
-    _conn.onError = (e) => _reportError(e);
+    _conn.onError = (e) {
+      if (_onClosed !== null) {
+        _onClosed(1006, "$e");
+      }
+    };
 
     // Generate the nonce now as it is also used to set the hash code.
     _generateNonceAndHash();
   }
 
   void set onRequest(void callback(HttpClientRequest request)) {
     _onRequest = callback;
   }
 
   void set onOpen(void callback()) {
@@ skipping 134 matching lines @@
         _onmessage(new _WebSocketMessageEvent(message));
       }
     };
     _wsconn.onClosed = (status, reason) {
       _readyState = WebSocket.CLOSED;
       if (_onclose != null) {
         _onclose(new _WebSocketCloseEvent(true, status, reason));
       }
     };
     _wsconn.onNoUpgrade = (response) {
-      if (_onerror != null) _onerror("Failed web socket connection");
-    };
-    _wsconn.onError = (e) {
-      if (_onerror != null) _onerror(e);
+      if (_onclose != null) {

[Søren Gjesse, 2012/09/04 07:17:10]

There is a lot of inconsistency in the use of != / !== when comparing to null.
Lets use !== for all new code.

[Anders Johnsen, 2012/09/04 07:21:27]

Done. (changed entire file for consistency).

+        _onclose(
+            new _WebSocketCloseEvent(true, 1006, "Connection not upgraded"));
+      }
     };
   }
 
   int get readyState => _readyState;
   int get bufferedAmount => 0;
 
   void set onopen(Function callback) {
     _onopen = callback;
   }
 
-  void set onerror(Function callback) {
-    _onerror = callback;
-  }
+  void set onerror(Function callback) {}
 
   void set onclose(Function callback) {
     _onclose = callback;
   }
 
   String get extensions => null;
   String get protocol => null;
 
   void close(int code, String reason) {
     if (_readyState < WebSocket.CLOSING) _readyState = WebSocket.CLOSING;
     _wsconn.close(code, reason);
   }
 
   void set onmessage(Function callback) {
     _onmessage = callback;
   }
 
   void send(data) {
     _wsconn.send(data);
   }
 
   WebSocketClientConnection _wsconn;
   int _readyState = WebSocket.CONNECTING;
   Function _onopen;
-  Function _onerror;
   Function _onclose;
   Function _onmessage;
 }
 
 
 class _WebSocketMessageEvent implements MessageEvent {
   _WebSocketMessageEvent(this._data);
   get data => _data;
   var _data;
 }
 
 
 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;
 }