Add bufferOutput to HttpServer, HttpResponse and HttpClientRequest.

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;
 
 const int _OUTGOING_BUFFER_SIZE = 8 * 1024;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 292 matching lines @@
               .then((request) => request.close());
           });
     }
 
     List<String> authChallenge() {
       return proxyAuth ? headers[HttpHeaders.PROXY_AUTHENTICATE]
                        : headers[HttpHeaders.WWW_AUTHENTICATE];
     }
 
     _Credentials findCredentials(_AuthenticationScheme scheme) {
-      return proxyAuth ? _httpClient._findProxyCredentials(_httpRequest._proxy, scheme)
+      return proxyAuth ? _httpClient._findProxyCredentials(_httpRequest._proxy,
+                                                           scheme)
                        : _httpClient._findCredentials(_httpRequest.uri, scheme);
     }
 
     void removeCredentials(_Credentials cr) {
       if (proxyAuth) {
         _httpClient._removeProxyCredentials(cr);
       } else {
         _httpClient._removeCredentials(cr);
       }
     }
@@ skipping 80 matching lines @@
     });
   }
 }
 
 
 abstract class _HttpOutboundMessage<T> extends _IOSinkImpl {
   // Used to mark when the body should be written. This is used for HEAD
   // requests and in error handling.
   bool _encodingSet = false;
 
+  bool _bufferOutput = true;
+
   final Uri _uri;
   final _HttpOutgoing _outgoing;
 
   final _HttpHeaders headers;
 
   _HttpOutboundMessage(Uri uri,
                        String protocolVersion,
                        _HttpOutgoing outgoing)
       : super(outgoing, null),
         _uri = uri,
@@ skipping 10 matching lines @@
   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;
   }
 
+  bool get bufferOutput => _bufferOutput;
+  void set bufferOutput(bool bufferOutput) {
+    if (_outgoing.headersWritten) throw new StateError("Header already sent");
+    _bufferOutput = bufferOutput;
+  }
+
+
   Encoding get encoding {
     if (_encodingSet && _outgoing.headersWritten) {
       return _encoding;
     }
     var charset;
     if (headers.contentType != null && headers.contentType.charset != null) {
       charset = headers.contentType.charset;
     } else {
       charset = "iso-8859-1";
     }
     return Encoding.getByName(charset);
   }
 
   void add(List<int> data) {
     if (data.length == 0) return;
     super.add(data);
   }
 
   void write(Object obj) {
     if (!_encodingSet) {
       _encoding = encoding;
       _encodingSet = true;
     }
     super.write(obj);
   }
 
   void _writeHeader();
+
+  bool get _isConnectionClosed => false;
 }
 
 
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
   int _statusCode = 200;
   String _reasonPhrase;
   List<Cookie> _cookies;
   _HttpRequest _httpRequest;
   Duration _deadline;
   Timer _deadlineTimer;
 
   _HttpResponse(Uri uri,
                 String protocolVersion,
                 _HttpOutgoing outgoing,
                 String serverHeader)
       : super(uri, protocolVersion, outgoing) {
     if (serverHeader != null) headers._add('server', serverHeader);
   }
 
+  bool get _isConnectionClosed => _httpRequest._httpConnection._isClosing;
+
   List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
   int get statusCode => _statusCode;
   void set statusCode(int statusCode) {
     if (_outgoing.headersWritten) throw new StateError("Header already sent");
     _statusCode = statusCode;
   }
@@ skipping 30 matching lines @@
   HttpConnectionInfo get connectionInfo => _httpRequest.connectionInfo;
 
   Duration get deadline => _deadline;
 
   void set deadline(Duration d) {
     if (_deadlineTimer != null) _deadlineTimer.cancel();
     _deadline = d;
 
     if (_deadline == null) return;
     _deadlineTimer = new Timer(_deadline, () {
-      _outgoing._socketError = true;
-      _outgoing.socket.destroy();
+      _httpRequest._httpConnection.destroy();
     });
   }
 
   void _writeHeader() {
     Uint8List buffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
     int offset = 0;
 
     void write(List<int> bytes) {
       int len = bytes.length;
       for (int i = 0; i < len; i++) {
@@ skipping 359 matching lines @@
             " bytes"));
       }
     }
     if (headersWritten) return null;
     headersWritten = true;
     Future drainFuture;
     bool isServerSide = outbound is _HttpResponse;
     bool gzip = false;
     if (isServerSide) {
       var response = outbound;
-      if (outbound.headers.chunkedTransferEncoding) {
+      if (outbound.bufferOutput && outbound.headers.chunkedTransferEncoding) {
         List acceptEncodings =
             response._httpRequest.headers[HttpHeaders.ACCEPT_ENCODING];
         List contentEncoding = outbound.headers[HttpHeaders.CONTENT_ENCODING];
         if (acceptEncodings != null &&
             acceptEncodings
                 .expand((list) => list.split(","))
                 .any((encoding) => encoding.trim().toLowerCase() == "gzip") &&
             contentEncoding == null) {
           outbound.headers.set(HttpHeaders.CONTENT_ENCODING, "gzip");
           gzip = true;
@@ skipping 103 matching lines @@
           }
         });
   }
 
   Future close() {
     // If we are already closed, return that future.
     if (_closeFuture != null) return _closeFuture;
     // If we earlier saw an error, return immediate. The notification to
     // _Http*Connection is already done.
     if (_socketError) return new Future.value(outbound);
+    if (outbound._isConnectionClosed) return new Future.value(outbound);
     if (!headersWritten && !ignoreBody) {
       if (outbound.headers.contentLength == -1) {
         // If no body was written, ignoreBody is false (it's not a HEAD
         // request) and the content-length is unspecified, set contentLength to
         // 0.
         outbound.headers.chunkedTransferEncoding = false;
         outbound.headers.contentLength = 0;
       } else if (outbound.headers.contentLength > 0) {
         var error = new HttpException(
               "No content even though contentLength was specified to be "
@@ skipping 86 matching lines @@
                 _addChunk(data, _gzipAdd);
               }));
     }
   }
 
   bool _ignoreError(error)
     => (error is SocketException || error is TlsException) &&
        outbound is HttpResponse;
 
   void _addGZipChunk(chunk, void add(List<int> data)) {
+    if (!outbound.bufferOutput) {
+      add(chunk);
+      return;
+    }
     if (chunk.length > _gzipBuffer.length - _gzipBufferLength) {
       add(new Uint8List.view(
           _gzipBuffer.buffer, 0, _gzipBufferLength));
       _gzipBuffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
       _gzipBufferLength = 0;
     }
     if (chunk.length > _OUTGOING_BUFFER_SIZE) {
       add(chunk);
     } else {
       _gzipBuffer.setRange(_gzipBufferLength,
                            _gzipBufferLength + chunk.length,
                            chunk);
       _gzipBufferLength += chunk.length;
     }
   }
 
   void _addChunk(chunk, void add(List<int> data)) {
+    if (!outbound.bufferOutput) {
+      if (_buffer != null) {
+        // If _buffer is not null, we have not written the header yet. Write
+        // it now.
+        add(new Uint8List.view(_buffer.buffer, 0, _length));
+        _buffer = null;
+        _length = 0;
+      }
+      add(chunk);
+      return;
+    }
     if (chunk.length > _buffer.length - _length) {
       add(new Uint8List.view(_buffer.buffer, 0, _length));
       _buffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
       _length = 0;
     }
     if (chunk.length > _OUTGOING_BUFFER_SIZE) {
       add(chunk);
     } else {
       _buffer.setRange(_length, _length + chunk.length, chunk);
       _length += chunk.length;
@@ skipping 1398 matching lines @@
   const _RedirectInfo(this.statusCode, this.method, this.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)';
 }