Use patching for dart:io.

lib/io/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 630 matching lines @@
     headers.remove(HttpHeaders.CONNECTION, "keep-alive");
     if (_protocolVersion == "1.1" && !persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "close");
     } else if (_protocolVersion == "1.0" && persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "keep-alive");
     }
   }
 
 
   bool _write(List<int> data, bool copyBuffer) {
-    if (_headResponse) return;
+    if (_headResponse) return true;
     _ensureHeadersSent();
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
       } else {
         _updateContentLength(data.length);
         allWritten = _httpConnection._write(data, copyBuffer);
       }
     }
     return allWritten;
   }
 
   bool _writeList(List<int> data, int offset, int count) {
-    if (_headResponse) return;
+    if (_headResponse) return true;
     _ensureHeadersSent();
     bool allWritten = true;
     if (count > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(count);
         _writeCRLF();
         _httpConnection._writeFrom(data, offset, count);
         allWritten = _writeCRLF();
       } else {
@@ skipping 455 matching lines @@
     } else if (_contentLength < 0 && _protocolVersion == "1.1") {
       _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
     var session = _httpConnection._request._session;
     if (session != null && !session._destroyed) {
       // Make sure we only send the current session id.
       bool found = false;
       for (int i = 0; i < cookies.length; i++) {
         if (cookies[i].name.toUpperCase() == _DART_SESSION_ID) {
-          cookie.value = session.id;
+          cookies[i].value = session.id;
           found = true;
           break;
         }
       }
       if (!found) {
         cookies.add(new Cookie(_DART_SESSION_ID, session.id));
       }
     }
     // Add all the cookies set to the headers.
     if (_cookies != null) {
@@ skipping 90 matching lines @@
   }
 
   void set onError(void callback(e)) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 
 
-class _HttpConnectionBase {
+abstract class _HttpConnectionBase {
   _HttpConnectionBase() : _httpParser = new _HttpParser(),
                           hashCode = _nextHashCode {
     _nextHashCode = (_nextHashCode + 1) & 0xFFFFFFF;
   }
 
   void _connectionEstablished(Socket socket) {
     _socket = socket;
     // Register handler for socket events.
     _socket.onData = _onData;
     _socket.onClosed = _onClosed;
@@ skipping 80 matching lines @@
     try {
       _HttpConnectionInfo info = new _HttpConnectionInfo();
       info.remoteHost = _socket.remoteHost;
       info.remotePort = _socket.remotePort;
       info.localPort = _socket.port;
       return info;
     } catch (e) { }
     return null;
   }
 
-  abstract void _onConnectionClosed(e);
-  abstract void _responseDone();
+  void _onConnectionClosed(e);
+  void _responseDone();
 
   void set _onNoPendingWrites(void callback()) {
     if (!_error) {
       _socket.outputStream.onNoPendingWrites = callback;
     }
   }
 
   Socket _socket;
   bool _closing = false;  // Is the socket closed by the client?
   bool _error = false;  // Is the socket closed due to an error?
@@ skipping 187 matching lines @@
     if (_server === null) {
       throw new HttpException("The HttpServer is not listening on a port.");
     }
     return _server.port;
   }
 
   void set onError(void callback(e)) {
     _onError = callback;
   }
 
-  int set sessionTimeout(int timeout) {
+  set sessionTimeout(int timeout) {
     _sessionManager.sessionTimeout = timeout;
   }
 
   void _handleRequest(HttpRequest request, HttpResponse response) {
     for (int i = 0; i < _handlers.length; i++) {
       if (_handlers[i]._matcher(request)) {
         Function handler = _handlers[i]._handler;
         try {
           handler(request, response);
         } catch (e) {
@@ skipping 213 matching lines @@
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
 
   void _handleUnauthorized() {
 
     void retryRequest(_Credentials cr) {
       if (cr != null) {
-        if (cr.scheme == _AuthenticationScheme.DIGEST) {
-          cr.nonce = header.parameters["nonce"];
-          cr.algorithm = header.parameters["algorithm"];
-          cr.qop = header.parameters["qop"];
-        }
         // Drain body and retry.
-        // TODO(sjgesse): Support digest.
+        // TODO(sgjesse): Support digest.
         if (cr.scheme == _AuthenticationScheme.BASIC) {
           inputStream.onData = inputStream.read;
           inputStream.onClosed = _connection.retry;
           return;
         }
       }
 
       // Fall through to here to perform normal response handling if
       // there is no sensible authorization handling.
       if (_connection._onResponse != null) {
@@ skipping 414 matching lines @@
   }
 
   HttpClientConnection getUrl(Uri url) => _openUrl("GET", url);
 
   HttpClientConnection post(String host, int port, String path) {
     return open("POST", host, port, path);
   }
 
   HttpClientConnection postUrl(Uri url) => _openUrl("POST", url);
 
-  set authenticate(bool f(Uri url, String scheme, String realm)) {
+  set authenticate(Future<bool> f(Uri url, String scheme, String realm)) {
     _authenticate = f;
   }
 
   void addCredentials(
       Uri url, String realm, HttpClientCredentials cr) {
     credentials.add(new _Credentials(url, realm, cr));
   }
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
@@ skipping 291 matching lines @@
   String realm;
   HttpClientCredentials credentials;
 
   // Digest specific fields.
   String nonce;
   String algorithm;
   String qop;
 }
 
 
-class _HttpClientCredentials implements HttpClientCredentials {
-  abstract _AuthenticationScheme get scheme;
-  abstract void authorize(HttpClientRequest request);
+abstract class _HttpClientCredentials implements HttpClientCredentials {
+  _AuthenticationScheme get scheme;
+  void authorize(HttpClientRequest request);
 }
 
 
 class _HttpClientBasicCredentials implements HttpClientBasicCredentials {
   _HttpClientBasicCredentials(this.username,
                               this.password);
 
   _AuthenticationScheme get scheme => _AuthenticationScheme.BASIC;
 
   void authorize(_Credentials _, HttpClientRequest request) {
@@ skipping 33 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;
 }