Remove Encoding-enum from dart:io and add interface in dart:convert.

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 392 matching lines @@
 
   final _HttpOutgoing _outgoing;
   final Uri _uri;
 
   final _HttpHeaders headers;
 
   _HttpOutboundMessage(Uri this._uri,
                        String protocolVersion,
                        _HttpOutgoing outgoing)
       : _outgoing = outgoing,
-        _headersSink = new IOSink(outgoing, encoding: Encoding.ASCII),
+        _headersSink = new IOSink(outgoing, encoding: ASCII),
         headers = new _HttpHeaders(protocolVersion) {
     _dataSink = new IOSink(new _HttpOutboundConsumer(this));
   }
 
   int get contentLength => headers.contentLength;
   void set contentLength(int contentLength) {
     headers.contentLength = contentLength;
   }
 
   bool get persistentConnection => headers.persistentConnection;
   void set persistentConnection(bool p) {
     headers.persistentConnection = p;
   }
 
   Encoding get encoding {
     var charset;
     if (headers.contentType != null && headers.contentType.charset != null) {
       charset = headers.contentType.charset;
     } else {
       charset = "iso-8859-1";
     }
-    return Encoding.fromName(charset);
+    return Encoding.getByName(charset);
   }
 
   void set encoding(Encoding value) {
     throw new StateError("IOSink encoding is not mutable");
   }
 
   void write(Object obj) {
     _dataSink.write(obj);
   }
 
@@ skipping 769 matching lines @@
     request.headers.host = uri.host;
     request.headers.port = port;
     request.headers.set(HttpHeaders.ACCEPT_ENCODING, "gzip");
     if (_httpClient.userAgent != null) {
       request.headers.set('User-Agent', _httpClient.userAgent);
     }
     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}"));
+          UTF8.encode("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     } else if (!proxy.isDirect && _httpClient._proxyCredentials.length > 0) {
       proxyCreds = _httpClient._findProxyCredentials(proxy);
       if (proxyCreds != null) {
         proxyCreds.authorize(request);
       }
     }
     if (uri.userInfo != null && !uri.userInfo.isEmpty) {
       // If the URL contains user information use that for basic
       // authorization.
       String auth =
-          _CryptoUtils.bytesToBase64(_encodeString(uri.userInfo));
+          _CryptoUtils.bytesToBase64(UTF8.encode(uri.userInfo));
       request.headers.set(HttpHeaders.AUTHORIZATION, "Basic $auth");
     } else {
       // Look for credentials.
       creds = _httpClient._findCredentials(uri);
       if (creds != null) {
         creds.authorize(request);
       }
     }
     // Start sending the request (lazy, delayed until the user provides
     // data).
@@ skipping 90 matching lines @@
   Future<_HttpClientConnection> createProxyTunnel(host, port, proxy, callback) {
     _HttpClientRequest request =
         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}"));
+          UTF8.encode("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     }
     return request.close()
         .then((response) {
           if (response.statusCode != HttpStatus.OK) {
             throw "Proxy failed to establish tunnel "
                   "(${response.statusCode} ${response.reasonPhrase})";
           }
           var socket = response._httpRequest._httpClientConnection._socket;
           return SecureSocket.secure(
@@ skipping 904 matching lines @@
   _Credentials(this.credentials, this.realm) {
     if (credentials.scheme == _AuthenticationScheme.DIGEST) {
       // Calculate the H(A1) value once. There is no mentioning of
       // username/password encoding in RFC 2617. However there is an
       // open draft for adding an additional accept-charset parameter to
       // the WWW-Authenticate and Proxy-Authenticate headers, see
       // http://tools.ietf.org/html/draft-reschke-basicauth-enc-06. For
       // now always use UTF-8 encoding.
       _HttpClientDigestCredentials creds = credentials;
       var hasher = new _MD5();
-      hasher.add(_encodeString(creds.username));
+      hasher.add(UTF8.encode(creds.username));
       hasher.add([_CharCode.COLON]);
       hasher.add(realm.codeUnits);
       hasher.add([_CharCode.COLON]);
-      hasher.add(_encodeString(creds.password));
+      hasher.add(UTF8.encode(creds.password));
       ha1 = _CryptoUtils.bytesToHex(hasher.close());
     }
   }
 
   _AuthenticationScheme get scheme => credentials.scheme;
 
   void authorize(HttpClientRequest request);
 }
 
 class _SiteCredentials extends _Credentials {
@@ skipping 68 matching lines @@
   _AuthenticationScheme get scheme => _AuthenticationScheme.BASIC;
 
   String authorization() {
     // There is no mentioning of username/password encoding in RFC
     // 2617. However there is an open draft for adding an additional
     // accept-charset parameter to the WWW-Authenticate and
     // Proxy-Authenticate headers, see
     // http://tools.ietf.org/html/draft-reschke-basicauth-enc-06. For
     // now always use UTF-8 encoding.
     String auth =
-        _CryptoUtils.bytesToBase64(_encodeString("$username:$password"));
+        _CryptoUtils.bytesToBase64(UTF8.encode("$username:$password"));
     return "Basic $auth";
   }
 
   void authorize(_Credentials _, HttpClientRequest request) {
     request.headers.set(HttpHeaders.AUTHORIZATION, authorization());
   }
 
   void authorizeProxy(_ProxyCredentials _, HttpClientRequest request) {
     request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, authorization());
   }
@@ skipping 89 matching lines @@
   final Uri location;
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }