Merge the dart:uri library into dart:core and update the Uri class

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>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 909 matching lines @@
       return result;
     }
 
     if (_proxy.isDirect) {
       return uriStartingFromPath();
     } else {
       if (method == "CONNECT") {
         // For the connect method the request URI is the host:port of
         // the requested destination of the tunnel (see RFC 2817
         // section 5.2)
-        return "${uri.domain}:${uri.port}";
+        return "${uri.host}:${uri.port}";
       } else {
         if (_httpClientConnection._proxyTunnel) {
           return uriStartingFromPath();
         } else {
           return uri.toString();
         }
       }
     }
   }
 
@@ skipping 188 matching lines @@
     _ProxyCredentials proxyCreds;  // Credentials used to authorize proxy.
     _SiteCredentials creds;  // Credentials used to authorize this request.
     var outgoing = new _HttpOutgoing(_socket);
     // Create new request object, wrapping the outgoing connection.
     var request = new _HttpClientRequest(outgoing,
                                          uri,
                                          method,
                                          proxy,
                                          _httpClient,
                                          this);
-    request.headers.host = uri.domain;
+    request.headers.host = uri.host;
     request.headers.port = port;
     request.headers.set(HttpHeaders.ACCEPT_ENCODING, "gzip");
     if (proxy.isAuthenticated) {
       // If the proxy configuration contains user information use that
       // for proxy basic authorization.
       String auth = CryptoUtils.bytesToBase64(
           _encodeString("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     } else if (!proxy.isDirect && _httpClient._proxyCredentials.length > 0) {
       proxyCreds = _httpClient._findProxyCredentials(proxy);
@@ skipping 102 matching lines @@
   void close() {
     closed = true;
     _httpClient._connectionClosed(this);
     _streamFuture
           // TODO(ajohnsen): Add timeout.
         .then((_) => _socket.destroy());
   }
 
   Future<_HttpClientConnection> createProxyTunnel(host, port, proxy) {
     _HttpClientRequest request =
-        send(new Uri.fromComponents(domain: host, port: port),
+        send(new Uri(host: host, port: port),
              port,
              "CONNECT",
              proxy);
     if (proxy.isAuthenticated) {
       // If the proxy configuration contains user information use that
       // for proxy basic authorization.
       String auth = CryptoUtils.bytesToBase64(
           _encodeString("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     }
@@ skipping 72 matching lines @@
           c.startTimer();
         }));
   }
 
   Future<HttpClientRequest> open(String method,
                                  String host,
                                  int port,
                                  String path) {
     // TODO(sgjesse): The path set here can contain both query and
     // fragment. They should be cracked and set correctly.
-    return _openUrl(method, new Uri.fromComponents(
-        scheme: "http", domain: host, port: port, path: path));
+    return _openUrl(method, new Uri(
+        scheme: "http", host: host, port: port, path: path));
   }
 
   Future<HttpClientRequest> openUrl(String method, Uri url) {
     return _openUrl(method, url);
   }
 
   Future<HttpClientRequest> get(String host,
                                 int port,
                                 String path) {
     return open("get", host, port, path);
@@ skipping 56 matching lines @@
     _proxyCredentials.add(new _ProxyCredentials(host, port, realm, cr));
   }
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
   Future<HttpClientRequest> _openUrl(String method, Uri uri) {
     if (method == null) {
       throw new ArgumentError(method);
     }
     if (method != "CONNECT") {
-      if (uri.domain.isEmpty ||
+      if (uri.host.isEmpty ||
           (uri.scheme != "http" && uri.scheme != "https")) {
         throw new ArgumentError("Unsupported scheme '${uri.scheme}' in $uri");
       }
     }
 
     bool isSecure = (uri.scheme == "https");
     int port = uri.port;
     if (port == 0) {
       port = isSecure ?
           HttpClient.DEFAULT_HTTPS_PORT :
           HttpClient.DEFAULT_HTTP_PORT;
     }
     // Check to see if a proxy server should be used for this connection.
     var proxyConf = const _ProxyConfiguration.direct();
     if (_findProxy != null) {
       // TODO(sgjesse): Keep a map of these as normally only a few
       // configuration strings will be used.
       try {
         proxyConf = new _ProxyConfiguration(_findProxy(uri));
       } catch (error, stackTrace) {
         return new Future.error(error, stackTrace);
       }
     }
-    return _getConnection(uri.domain, port, proxyConf, isSecure)
+    return _getConnection(uri.host, port, proxyConf, isSecure)
         .then((info) {
           send(info) {
             return info.connection.send(uri,
                                         port,
                                         method.toUpperCase(),
                                         info.proxy);
           }
           // If the connection was closed before the request was sent, create
           // and use another connection.
           if (info.connection.closed) {
-            return _getConnection(uri.domain, port, proxyConf, isSecure)
+            return _getConnection(uri.host, port, proxyConf, isSecure)
                 .then(send);
           }
           return send(info);
         });
   }
 
   Future<HttpClientRequest> _openUrlFromRequest(String method,
                                                 Uri uri,
                                                 _HttpClientRequest previous) {
     // If the new URI is relative (to either '/' or some sub-path),
     // construct a full URI from the previous one.
     // See http://tools.ietf.org/html/rfc3986#section-4.2
-    replaceComponents({scheme, domain, port, path}) {
-      uri = new Uri.fromComponents(
+    replaceComponents({scheme, host, port, path}) {
+      uri = new Uri(
           scheme: scheme != null ? scheme : uri.scheme,
-          domain: domain != null ? domain : uri.domain,
+          host: host != null ? host : uri.host,
           port: port != null ? port : uri.port,
           path: path != null ? path : uri.path,
           query: uri.query,
           fragment: uri.fragment);
     }
-    if (uri.domain == '') {
-      replaceComponents(domain: previous.uri.domain, port: previous.uri.port);
+    if (uri.host.isEmpty) {
+      replaceComponents(host: previous.uri.host, port: previous.uri.port);
     }
-    if (uri.scheme == '') {
+    if (uri.scheme.isEmpty) {
       replaceComponents(scheme: previous.uri.scheme);
     }
     if (!uri.path.startsWith('/') && previous.uri.path.startsWith('/')) {
       var absolute = new Path.raw(previous.uri.path).directoryPath;
       absolute = absolute.join(new Path.raw(uri.path));
       replaceComponents(path: absolute.canonicalize().toString());
     }
     return openUrl(method, uri).then((_HttpClientRequest request) {
           // Only follow redirects if initial request did.
           request.followRedirects = previous.followRedirects;
@@ skipping 146 matching lines @@
       _proxyCredentials.removeAt(index);
     }
   }
 
   static String _findProxyFromEnvironment(Uri url,
                                           Map<String, String> environment) {
     checkNoProxy(String option) {
       if (option == null) return null;
       Iterator<String> names = option.split(",").map((s) => s.trim()).iterator;
       while (names.moveNext()) {
-        if (url.domain.endsWith(names.current)) {
+        if (url.host.endsWith(names.current)) {
           return "DIRECT";
         }
       }
       return null;
     }
 
     checkProxy(String option) {
       if (option == null) return null;
       int pos = option.indexOf("://");
       if (pos >= 0) {
@@ skipping 475 matching lines @@
 }
 
 class _SiteCredentials extends _Credentials {
   Uri uri;
 
   _SiteCredentials(this.uri, realm, _HttpClientCredentials creds)
   : super(creds, realm);
 
   bool applies(Uri uri, _AuthenticationScheme scheme) {
     if (scheme != null && credentials.scheme != scheme) return false;
-    if (uri.domain != this.uri.domain) return false;
+    if (uri.host != this.uri.host) return false;
     int thisPort =
         this.uri.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : this.uri.port;
     int otherPort = uri.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : uri.port;
     if (otherPort != thisPort) return false;
     return uri.path.startsWith(this.uri.path);
   }
 
   void authorize(HttpClientRequest request) {
     // Digest credentials cannot be used without a nonce from the
     // server.
@@ skipping 152 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;
 }