Implemented W3C complient web socket client interface

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.
 
 final String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static final int NONE = 0;
   static final int BINARY = 1;
   static final int TEXT = 2;
@@ skipping 328 matching lines @@
 
   Function onMessageStart;
   Function onMessageData;
   Function onMessageEnd;
   Function onClosed;
   Function onError;
 }
 
 
 class _WebSocketConnectionBase  {
-  void _socketReady(DetachedSocket detached) {
-    assert(detached.socket != null);
-    _socket = detached.socket;
+  void _socketConnected(Socket socket) {
+    _socket = socket;
+    _socket.onError = (e) {
+      _reportError(e);
+      _socket.close();
+    };
+  }
+
+  void _startProcessing(List<int> unparsedData) {
     _WebSocketProtocolProcessor processor = new _WebSocketProtocolProcessor();
     processor.onMessageStart = _onWebSocketMessageStart;
     processor.onMessageData = _onWebSocketMessageData;
     processor.onMessageEnd = _onWebSocketMessageEnd;
     processor.onClosed = _onWebSocketClosed;
     processor.onError = _onWebSocketError;
-    if (detached.unparsedData != null) {
-      processor.update(detached.unparsedData, 0, detached.unparsedData.length);
+    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"));
       }
       _socket.close();
     };
-    _socket.onError = (e) {
-      _reportError(e);
-      _socket.close();
-    };
   }
 
   void set onMessage(void callback(Object message)) {
     _onMessage = callback;
   }
 
   void set onClosed(void callback(int status, String reason)) {
     _onClosed = callback;
   }
 
@@ skipping 161 matching lines @@
   _StringDecoder _decoder;
   ListOutputStream _outputStream;
   bool _closeReceived = false;
   bool _closeSent = false;
 }
 
 
 class _WebSocketConnection
     extends _WebSocketConnectionBase implements WebSocketConnection {
   _WebSocketConnection(DetachedSocket detached) {
-    _socketReady(detached);
+    _socketConnected(detached.socket);
+    _startProcessing(detached.unparsedData);
   }
 }
 
 
 class _WebSocketHandler implements WebSocketHandler {
   void onRequest(HttpRequest request, HttpResponse response) {
     // Check that this is a web socket upgrade.
     if (!_isWebSocketUpgrade(request)) {
       response.statusCode = HttpStatus.BAD_REQUEST;
       response.outputStream.close();
@@ skipping 97 matching lines @@
       return;
     }
 
     if (!_isWebSocketUpgrade(response)) {
       _conn.detachSocket().socket.close();
       throw new WebSocketException("Protocol upgrade failed");
       return;
     }
 
     // Connection upgrade successful.
-    _socketReady(_conn.detachSocket());
+    DetachedSocket detached = _conn.detachSocket();
+    _socketConnected(detached.socket);
     if (_onOpen != null) _onOpen();
+    _startProcessing(detached.unparsedData);
   }
 
   void _generateNonce() {
     assert(_nonce == null);
     void intToBigEndianBytes(int value, List<int> bytes, int offset) {
       bytes[offset] = (value >> 24) & 0xFF;
       bytes[offset + 1] = (value >> 16) & 0xFF;
       bytes[offset + 2] = (value >> 8) & 0xFF;
       bytes[offset + 3] = value & 0xFF;
     }
@@ skipping 33 matching lines @@
     }
     return true;
   }
 
   Function _onRequest;
   Function _onOpen;
   Function _onNoUpgrade;
   HttpClientConnection _conn;
   String _nonce;
 }
+
+
+class _WebSocket implements WebSocket {
+  _WebSocket(String url, [protocols]) {
+    Uri uri = new Uri.fromString(url);
+    if (uri.scheme != "ws") {
+      throw new WebSocketException("Unsupported URL scheme ${uri.scheme}");
+    }
+    if (uri.userInfo != "") {
+      throw new WebSocketException("Unsupported user info ${uri.userInfo}");
+    }
+    int port = uri.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : uri.port;
+    String path;
+    if (uri.query != "") {
+      if (uri.fragment != "") {
+        path = "${uri.path}?${uri.query}#${uri.fragment}";
+      } else {
+        path = "${uri.path}?${uri.query}";
+      }
+    } else {
+      path = uri.path;
+    }
+
+    HttpClient client = new HttpClient();
+    HttpClientConnection conn = client.open("GET", uri.domain, port, path);
+    if (protocols is String) protocols = [protocols];
+    _wsconn = new WebSocketClientConnection(conn, protocols);
+    _wsconn.onOpen = () {
+      // HTTP client not needed after socket have been detached.
+      client.shutdown();
+      client = null;
+      _readyState = WebSocket.OPEN;
+      if (_onopen != null) _onopen();
+    };
+    _wsconn.onMessage = (message) {
+      if (_onmessage != null) {
+        _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);
+    };
+  }
+
+  int get readyState() => _readyState;
+  int get bufferedAmount() => 0;
+
+  void set onopen(Function callback) {
+    _onopen = callback;
+  }
+
+  void set onerror(Function callback) {
+    _onerror = 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;
+}