Add a web socket client

runtime/bin/http_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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 449 matching lines @@
   }
 
   OutputStream get outputStream() {
     if (_state >= DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
-  Socket detachSocket() {
+  DetachedSocket detachSocket() {
     if (_state >= DONE) throw new HttpException("Response closed");
     // Ensure that headers are written.
     if (_state == START) {
       _writeHeader();
     }
     _state = UPGRADED;
     // Ensure that any trailing data is written.
     _writeDone();
     // Indicate to the connection that the response handling is done.
     return _httpConnection._detachSocket();
@@ skipping 114 matching lines @@
     // Determine the value of the "Connection" header.
     if (_protocolVersion == "1.1" && !_persistentConnection) {
       _headers.set("Connection", "close");
     } else if (_protocolVersion == "1.0" && _persistentConnection) {
       _headers.set("Connection", "keep-alive");
     }
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength > 0) {
       _headers.set("Content-Length", _contentLength.toString());
-    } else {
+    } else if (_contentLength < 0) {
       _headers.set("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADER_SENT;
     return allWritten;
   }
 
   // Response status code.
@@ skipping 122 matching lines @@
     if (available == 0) {
       return;
     }
 
     ByteArray buffer = new ByteArray(available);
     int bytesRead = _socket.readList(buffer, 0, available);
     if (bytesRead > 0) {
       int parsed = _httpParser.writeList(buffer, 0, bytesRead);
       if (!_httpParser.upgrade) {
         if (parsed != bytesRead) {
-          // TODO(sgjesse): Error handling.
-          _close();
+          if (_socket != null) {
+            // TODO(sgjesse): Error handling.
+            _close();
+          }
         }
       }
     }
   }
 
   void _onClosed() {
     _closing = true;
     _onConnectionClosed(null);
   }
 
   void _onError(e) {
     // If an error occurs, make sure to close the socket if one is associated.
     _error = true;
     if (_socket != null) {
       _socket.close();
     }
     _onConnectionClosed(e);
   }
 
-  Socket _detachSocket() {
+  DetachedSocket _detachSocket() {
     _socket.onData = null;
-    // TODO(sgjesse): Handle getting the write handler when using output stream.
-    //_socket.onWrite = null;
     _socket.onClosed = null;
     _socket.onError = null;
+    _socket.outputStream.onNoPendingWrites = null;
     Socket socket = _socket;
     _socket = null;
-    if (onDetach) onDetach();
-    return socket;
+    if (onDetach != null) onDetach();
+    return new _DetachedSocket(socket, _httpParser.unparsedData);
   }
 
   abstract void _onConnectionClosed(e);
   abstract void _responseDone();
 
   void set _onNoPendingWrites(void callback()) {
     if (!_error) {
       _socket.outputStream.onNoPendingWrites = callback;
     }
   }
@@ skipping 435 matching lines @@
     _socketConn = null;
   }
 
   HttpClientRequest open(String method, String uri) {
     _method = method;
     _request = new _HttpClientRequest(method, uri, this);
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
+  DetachedSocket detachSocket() {
+    return _detachSocket();
+  }
+
   void _onConnectionClosed(e) {
     // Socket is closed either due to an error or due to normal socket close.
     if (e != null) {
       if (_onErrorCallback != null) {
         _onErrorCallback(e);
       }
     }
     _closing = true;
     if (e != null) {
       // Propagate the error to the streams.
@@ skipping 255 matching lines @@
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }
+
+
+class _DetachedSocket implements DetachedSocket {
+  _DetachedSocket(this._socket, this._unparsedData);
+  Socket get socket() => _socket;
+  List<int> get unparsedData() => _unparsedData;
+  Socket _socket;
+  List<int> _unparsedData;
+}