IO v2: Update a number of HTTP tests to pass

sdk/lib/io/http_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;
 
 class _HttpIncoming
     extends Stream<List<int>> implements StreamSink<List<int>> {
   final Function _pause;
   final Function _resume;
@@ skipping 143 matching lines @@
   String get method => _incoming.method;
 
   HttpSession get session {
     if (_session != null) {
       // It's already mapped, use it.
       return _session;
     }
     // Create session, store it in connection, and return.
     return _session = _httpServer._sessionManager.createSession();
   }
+
+  HttpConnectionInfo get connectionInfo => _httpConnection.connectionInfo;
 }
 
 
 class _HttpClientResponse
     extends _HttpInboundMessage implements HttpClientResponse {
   List<RedirectInfo> get redirects => _httpRequest._responseRedirects;
 
   // The HttpClient this response belongs to.
   final _HttpClient _httpClient;
 
@@ skipping 79 matching lines @@
                             onError: onError,
                             onDone: onDone,
                             unsubscribeOnError: unsubscribeOnError);
   }
 
   Future<Socket> detachSocket() {
     _httpClient._connectionClosed(_httpRequest._httpClientConnection);
     return _httpRequest._httpClientConnection.detachSocket();
   }
 
+  HttpConnectionInfo get connectionInfo => _httpRequest.connectionInfo;
+
   bool get _shouldAuthenticate {
     // Only try to authenticate if there is a challenge in the response.
     List<String> challenge = headers[HttpHeaders.WWW_AUTHENTICATE];
     return statusCode == HttpStatus.UNAUTHORIZED &&
         challenge != null && challenge.length == 1;
   }
 
   Future<HttpClientResponse> _authenticate() {
     Future<HttpClientResponse> retryWithCredentials(_Credentials cr) {
       if (cr != null) {
@@ skipping 162 matching lines @@
 
   Future<Socket> detachSocket() {
     if (_headersWritten) throw new StateError("Headers already sent");
     _writeHeaders();
     var future = _httpRequest._httpConnection.detachSocket();
     // Close connection so the socket is 'free'.
     close();
     return future;
   }
 
+  HttpConnectionInfo get connectionInfo => _httpRequest.connectionInfo;
+
   void _fullBodyWritten() {
     if (!_httpRequest._incoming.fullBodyRead) {
       _httpRequest._httpConnection._socket.destroy();
     }
   }
 
   void _writeHeader() {
     writeSP() => add([_CharCode.SP]);
     writeCRLF() => add([_CharCode.CR, _CharCode.LF]);
 
@@ skipping 145 matching lines @@
     if (_headersWritten) throw new StateError("Request already sent");
     _maxRedirects = maxRedirects;
   }
 
   bool get followRedirects => _followRedirects;
   void set followRedirects(bool followRedirects) {
     if (_headersWritten) throw new StateError("Request already sent");
     _followRedirects = followRedirects;
   }
 
+  HttpConnectionInfo get connectionInfo => _httpClientConnection.connectionInfo;
+
   void _onIncoming(_HttpIncoming incoming) {
     var response = new _HttpClientResponse(incoming,
                                            this,
                                           _httpClient);
     Future<HttpClientResponse> future;
     if (followRedirects && response.isRedirect) {
       if (response.redirects.length < maxRedirects) {
         // Redirect and drain response.
         future = response.reduce(null, (x, y) {})
           .then((_) => response.redirect());
@@ skipping 292 matching lines @@
         });
   }
 
   Future<Socket> detachSocket() {
     return new Future.immediate(
         new _DetachedSocket(_socket, _parser.detachIncoming()));
   }
 
   // TODO(ajohnsen): Remove socket from httpclient.
   void destroy() => _socket.destroy();
+
+  HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
 }
 
 class _ConnnectionInfo {
   _ConnnectionInfo(_HttpClientConnection this.connection, _Proxy this.proxy);
   final _HttpClientConnection connection;
   final _Proxy proxy;
 }
 
 
 class _HttpClient implements HttpClient {
@@ skipping 297 matching lines @@
     // Remove connection from server.
     _httpServer._connectionClosed(this);
 
     _HttpDetachedIncoming detachedIncoming = _httpParser.detachIncoming();
 
     return _writeDoneFuture.then((_) {
       return new _DetachedSocket(_socket, detachedIncoming);
     });
   }
 
+  HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
+
   bool get _isActive => _state == _ACTIVE;
   bool get _isIdle => _state == _IDLE;
   bool get _isClosing => _state == _CLOSING;
 }
 
 
 // HTTP server waiting for socket connections.
 class _HttpServer extends Stream<HttpRequest> implements HttpServer {
 
   static Future<HttpServer> bind(String host, int port, int backlog) {
@@ skipping 155 matching lines @@
   const _Proxy(this.host, this.port) : isDirect = false;
   const _Proxy.direct() : host = null, port = null, isDirect = true;
 
   final String host;
   final int port;
   final bool isDirect;
 }
 
 
 class _HttpConnectionInfo implements HttpConnectionInfo {
+  static _HttpConnectionInfo create(Socket socket) {
+    if (socket == null) return null;
+    try {
+      _HttpConnectionInfo info = new _HttpConnectionInfo._();
+      info.remoteHost = socket.remoteHost;
+      info.remotePort = socket.remotePort;
+      info.localPort = socket.port;
+      return info;
+    } catch (e) { }
+    return null;
+  }
+
+  _HttpConnectionInfo._();
+
   String remoteHost;
   int remotePort;
   int localPort;
 }
 
+
 class _DetachedSocket implements Socket {
   final Stream<List<int>> _incoming;
   final Socket _socket;
 
   _DetachedSocket(this._socket, this._incoming);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(AsyncError error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
@@ skipping 122 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }