Refactor HttpClient internals to use Uri class for passing connection information

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 1940 matching lines @@
 
 class _HttpClient implements HttpClient {
   static const int DEFAULT_EVICTION_TIMEOUT = 60000;
 
   _HttpClient() : _openSockets = new Map(),
                   _activeSockets = new Set(),
                   _shutdown = false;
 
   HttpClientConnection open(
       String method, String host, int port, String path) {
-    return _open(method, host, port, path);
+    // TODO(sgjesse): The path set here can contain both query and
+    // fragment. They should be cracked and set correctly.
+    return _open(method, new Uri.fromComponents(
+        scheme: "http", domain: host, port: port, path: path));
   }
 
   HttpClientConnection _open(String method,
-                             String host,
-                             int port,
-                             String path,
+                             Uri uri,
                              [_HttpClientConnection connection]) {
     if (_shutdown) throw new HttpException("HttpClient shutdown");
-    if (method == null || host == null || port == null || path == null) {
+    if (method == null || uri.domain.isEmpty() == null) {
       throw new ArgumentError(null);
     }
-    return _prepareHttpClientConnection(host, port, method, path, connection);
+    return _prepareHttpClientConnection(method, uri, connection);
   }
 
   HttpClientConnection openUrl(String method, Uri url) {
     _openUrl(method, url);
   }
 
   HttpClientConnection _openUrl(String method,
                                 Uri url,
                                 [_HttpClientConnection connection]) {
     if (url.scheme != "http") {
       throw new HttpException("Unsupported URL scheme ${url.scheme}");
     }
     if (url.userInfo != "") {
       throw new HttpException("Unsupported user info ${url.userInfo}");
     }
-    int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
-    String path;
-    if (url.query != "") {
-      if (url.fragment != "") {
-        path = "${url.path}?${url.query}#${url.fragment}";
-      } else {
-        path = "${url.path}?${url.query}";
-      }
-    } else {
-      path = url.path;
-    }
-    return _open(method, url.domain, port, path, connection);
+    return _open(method, url, connection);
   }
 
   HttpClientConnection get(String host, int port, String path) {
-    return _open("GET", host, port, path);
+    return open("GET", host, port, path);
   }
 
   HttpClientConnection getUrl(Uri url) => _openUrl("GET", url);
 
   HttpClientConnection post(String host, int port, String path) {
-    return _open("POST", host, port, path);
+    return open("POST", host, port, path);
   }
 
   HttpClientConnection postUrl(Uri url) => _openUrl("POST", url);
 
   void shutdown() {
      _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
        while (!connections.isEmpty()) {
          _SocketConnection socketConn = connections.removeFirst();
          socketConn._socket.close();
        }
      });
      _activeSockets.forEach((_SocketConnection socketConn) {
        socketConn._socket.close();
      });
     if (_evictionTimer != null) _cancelEvictionTimer();
      _shutdown = true;
   }
 
   void _cancelEvictionTimer() {
     _evictionTimer.cancel();
     _evictionTimer = null;
   }
 
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
-    String host,
-    int port,
     String method,
-    String path,
+    Uri url,
     [_HttpClientConnection connection]) {
 
     void _connectionOpened(_SocketConnection socketConn,
                            _HttpClientConnection connection) {
       connection._connectionEstablished(socketConn);
+      String path;
+      if (url.query != "") {
+        if (url.fragment != "") {
+          path = "${url.path}?${url.query}#${url.fragment}";
+        } else {
+          path = "${url.path}?${url.query}";
+        }
+      } else {
+        path = url.path;
+      }
       HttpClientRequest request = connection.open(method, path);
-      request.headers.host = host;
-      request.headers.port = port;
+      request.headers.host = socketConn._host;

[Anders Johnsen, 2012/10/04 13:15:29]

Why not url.domain/url.port?

[Søren Gjesse, 2012/10/04 14:11:48]

That was wrong fixed.

+      request.headers.port = socketConn._port;
       if (connection._onRequest != null) {
         connection._onRequest(request);
       } else {
         request.outputStream.close();
       }
     }
 
     // Create a new connection if we are not re-using an existing one.
     if (connection == null) {
       connection = new _HttpClientConnection(this);
     }
     connection.onDetach = () => _activeSockets.remove(connection._socketConn);
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
+    String host = url.domain;
+    int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
     String key = _connectionKey(host, port);
     Queue socketConnections = _openSockets[key];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
       // Until the connection is established handle connection errors
       // here as the HttpClientConnection object is not yet associated
       // with the socket.
       socket.onError = (e) {
         // Report the error through the HttpClientConnection object to
         // the client.
@@ skipping 75 matching lines @@
 
     // Return connection.
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
+  Function _findProxy;

[Anders Johnsen, 2012/10/04 13:15:29]

I guess this is an (too) early start on proxy? :)

   bool _shutdown;  // Has this HTTP client been shutdown?
 }
 
 
 class _HttpConnectionInfo implements HttpConnectionInfo {
   String remoteHost;
   int remotePort;
   int localPort;
 }
 
 
 class _DetachedSocket implements DetachedSocket {
   _DetachedSocket(this._socket, this._unparsedData);
   Socket get socket => _socket;
   List<int> get unparsedData => _unparsedData;
   Socket _socket;
   List<int> _unparsedData;
 }
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }