Support GZip encoding on the http server.

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 304 matching lines @@
     return new Future.immediate(this);
   }
 }
 
 
 abstract class _HttpOutboundMessage<T> implements IOSink {
   // Used to mark when the body should be written. This is used for HEAD
   // requests and in error handling.
   bool _ignoreBody = false;
   bool _headersWritten = false;
-  bool _chunked = false;
 
-  final IOSink _ioSink;
+  IOSink _ioSink;
   final _HttpOutgoing _outgoing;
 
   final _HttpHeaders headers;
 
   _HttpOutboundMessage(String protocolVersion, _HttpOutgoing outgoing)
       : _outgoing = outgoing,
-      _ioSink = new IOSink(outgoing, encoding: Encoding.ASCII),
+        _ioSink = new IOSink(outgoing, encoding: Encoding.ASCII),
         headers = new _HttpHeaders(protocolVersion);
 
   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);
   }
 
   void set encoding(Encoding value) {
     throw new StateError("IOSink encoding is not mutable");
   }
 
   void write(Object obj) {
     _writeHeaders();
-    if (_ignoreBody) return;
     // This comment is copied from runtime/lib/string_buffer_patch.dart.
     // TODO(srdjan): The following four lines could be replaced by
     // '$obj', but apparently this is too slow on the Dart VM.
     String string;
     if (obj is String) {
       string = obj;
     } else {
       string = obj.toString();
       if (string is! String) {
         throw new ArgumentError('toString() did not return a string');
       }
     }
     if (string.isEmpty) return;
-    if (_chunked) {
-      _ChunkedTransformer._addChunk(_encodeString(string, encoding),
-                                    _ioSink.writeBytes);
-    } else {
-      _ioSink.write(string);
-    }
+    _ioSink.write(string);
   }
 
   void writeAll(Iterable objects) {
     for (Object obj in objects) write(obj);
   }
 
   void writeln(Object obj) {
     write(obj);
     write("\n");
   }
 
   void writeCharCode(int charCode) {
     write(new String.fromCharCode(charCode));
   }
 
   void writeBytes(List<int> data) {
     _writeHeaders();
-    if (_ignoreBody || data.length == 0) return;
-    if (_chunked) {
-      _ChunkedTransformer._addChunk(data, _ioSink.writeBytes);
-    } else {
-      _ioSink.writeBytes(data);
-    }
+    if (data.length == 0) return;
+    _ioSink.writeBytes(data);
   }
 
   Future<T> consume(Stream<List<int>> stream) {
     _writeHeaders();
-    if (_ignoreBody) return new Future.immediate(this);
-    if (_chunked) {
-      // Transform when chunked.
-      stream = stream.transform(new _ChunkedTransformer());
-    }
-    return _ioSink.consume(stream).then((_) => this);
+    return _ioSink.consume(stream);
   }
 
   Future<T> writeStream(Stream<List<int>> stream) {
     _writeHeaders();
-    if (_ignoreBody) return new Future.immediate(this);
-    if (_chunked) {
-      // Transform when chunked.
-      stream = stream.transform(new _ChunkedTransformer(writeEnd: false));
-    }
     return _ioSink.writeStream(stream).then((_) => this);
   }
 
   void close() {
     if (!_headersWritten && !_ignoreBody && headers.chunkedTransferEncoding) {
       // If no body was written, _ignoreBody is false (it's not a HEAD
       // request) and the content-length is unspecified, set contentLength to 0.
+      headers.chunkedTransferEncoding = false;
       headers.contentLength = 0;
     }
     _writeHeaders();
-    if (!_ignoreBody) {
-      if (_chunked) {
-        _ChunkedTransformer._addChunk([], _ioSink.writeBytes);
-      }
-    }
     _ioSink.close();
   }
 
-  Future<T> get done => _ioSink.done.then((_) => this);
+  Future<T> get done {
+    _writeHeaders();
+    return _ioSink.done;
+  }
 
   void _writeHeaders() {
     if (_headersWritten) return;
     _headersWritten = true;
     _ioSink.encoding = Encoding.ASCII;
+    headers._synchronize();  // Be sure the 'chunked' option is updated.
+    bool asGZip = false;
+    bool isServerSide = this is _HttpResponse;
+    if (isServerSide && headers.chunkedTransferEncoding) {
+      List acceptEncodings =
+          _httpRequest.headers[HttpHeaders.ACCEPT_ENCODING];
+      List contentEncoding = headers[HttpHeaders.CONTENT_ENCODING];
+      if (acceptEncodings != null &&
+          acceptEncodings.any((encoding) => encoding.toLowerCase() == "gzip") &&
+          contentEncoding == null) {
+        headers.set(HttpHeaders.CONTENT_ENCODING, "gzip");
+        asGZip = true;
+      }
+    }
     _writeHeader();
+    _ioSink = new IOSink(new _HttpOutboundConsumer(_ioSink, _consume, asGZip));
     _ioSink.encoding = encoding;
+  }
+
+  Future _consume(IOSink ioSink, Stream<List<int>> stream, bool asGZip) {
+    int contentLength = headers.contentLength;
     if (_ignoreBody) {
-      _ioSink.close();
-      return;
+      ioSink.close();
+      return stream.reduce(null, (x, y) {}).then((_) => this);
     }
-    _chunked = headers.chunkedTransferEncoding;
-    if (headers.contentLength >= 0) {
-      _outgoing.setTransferLength(headers.contentLength);
+    if (headers.chunkedTransferEncoding) {
+      if (asGZip) {
+        stream = stream.transform(new ZLibDeflater(gzip: true, level: 6));
+      }
+      stream = stream.transform(new _ChunkedTransformer());
+    } else if (contentLength >= 0) {
+      stream = stream.transform(new _ContentLengthValidator(contentLength));
     }
+    return stream.pipe(ioSink).then((_) => this);
   }
 
   void _writeHeader();  // TODO(ajohnsen): Better name.
 }
 
 
+class _HttpOutboundConsumer implements StreamConsumer {
+  Function _consume;
+  IOSink _ioSink;
+  bool _asGZip;
+  _HttpOutboundConsumer(IOSink this._ioSink,
+                        Function this._consume,
+                        bool this._asGZip);
+
+  Future consume(var stream) => _consume(_ioSink, stream, _asGZip);
+}
+
+
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
   int statusCode = 200;
   String _reasonPhrase;
   List<Cookie> _cookies;
   _HttpRequest _httpRequest;
 
   _HttpResponse(String protocolVersion,
                 _HttpOutgoing _outgoing)
       : super(protocolVersion, _outgoing);
@@ skipping 262 matching lines @@
 
     // Write headers.
     headers._write(_ioSink);
     writeCRLF();
   }
 }
 
 
 // Transformer that transforms data to HTTP Chunked Encoding.
 class _ChunkedTransformer extends StreamEventTransformer<List<int>, List<int>> {
-  final bool writeEnd;
-  _ChunkedTransformer({this.writeEnd: true});
-
   void handleData(List<int> data, EventSink<List<int>> sink) {
-    _addChunk(data, sink.add);
+    sink.add(_chunkHeader(data.length));
+    if (data.length > 0) sink.add(data);
+    sink.add(_chunkFooter);
   }
 
   void handleDone(EventSink<List<int>> sink) {
-    if (writeEnd) {
-      _addChunk([], sink.add);
-    }
+    handleData([], sink);
     sink.close();
   }
 
-  static void _addChunk(List<int> data, void add(List<int> data)) {
-    add(_chunkHeader(data.length));
-    if (data.length > 0) add(data);
-    add(_chunkFooter);
-  }
-
   static List<int> _chunkHeader(int length) {
     const hexDigits = const [0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
                              0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46];
     var header = [];
     if (length == 0) {
       header.add(hexDigits[length]);
     } else {
       while (length > 0) {
         header.insertRange(0, 1, hexDigits[length % 16]);
         length = length >> 4;
       }
     }
     header.add(_CharCode.CR);
     header.add(_CharCode.LF);
     return header;
   }
 
   // Footer is just a CRLF.
   static List<int> get _chunkFooter => const [_CharCode.CR, _CharCode.LF];
 }
 
 
-// Transformer that invokes [_onDone] when completed.
-class _DoneTransformer implements StreamTransformer<List<int>, List<int>> {
-  final StreamController<List<int>> _controller
-      = new StreamController<List<int>>();
-  final Function _onDone;
+// Transformer that validates the content length.
+class _ContentLengthValidator
+    extends StreamEventTransformer<List<int>, List<int>> {
+  final int expectedContentLength;
+  int _bytesWritten = 0;
 
-  _DoneTransformer(this._onDone);
+  _ContentLengthValidator(int this.expectedContentLength);
 
-  Stream<List<int>> bind(Stream<List<int>> stream) {
-    var subscription = stream.listen(
-        _controller.add,
-        onError: _controller.addError,
-        onDone: () {
-          _onDone();
-          _controller.close();
-        });
-    return _controller.stream;
+  void handleData(List<int> data, EventSink<List<int>> sink) {
+    _bytesWritten += data.length;
+    if (_bytesWritten > expectedContentLength) {
+      sink.addError(new AsyncError(new HttpException(
+          "Content size exceeds specified contentLength. "
+          "$_bytesWritten bytes written while expected "
+          "$expectedContentLength. "
+          "[${new String.fromCharCodes(data)}]")));
+      sink.close();
+    } else {
+      sink.add(data);
+    }
+  }
+
+  void handleDone(EventSink<List<int>> sink) {
+    if (_bytesWritten < expectedContentLength) {
+      sink.addError(new AsyncError(new HttpException(
+          "Content size below specified contentLength. "
+          " $_bytesWritten bytes written while expected "
+          "$expectedContentLength.")));
+    }
+    sink.close();
   }
 }
 
-// Transformer that validates the data written.
-class _DataValidatorTransformer
-    implements StreamTransformer<List<int>, List<int>> {
-  final StreamController<List<int>> _controller =
-      new StreamController<List<int>>();
-  int _bytesWritten = 0;
-
-  int expectedTransferLength;
-
-  Stream<List<int>> bind(Stream<List<int>> stream) {
-    var subscription;
-    subscription = stream.listen(
-        (data) {
-          if (expectedTransferLength != null) {
-            _bytesWritten += data.length;
-            if (_bytesWritten > expectedTransferLength) {
-              subscription.cancel();
-              _controller.addError(new HttpException(
-                  "Content size exceeds specified contentLength. "
-                  "$_bytesWritten bytes written while expected "
-                  "$expectedTransferLength. "
-                  "[${new String.fromCharCodes(data)}]"));
-              _controller.close();
-              return;
-            }
-          }
-          _controller.add(data);
-        },
-        onError: (error) {
-          _controller.addError(error);
-          _controller.close();
-        },
-        onDone: () {
-          if (expectedTransferLength != null) {
-            if (_bytesWritten < expectedTransferLength) {
-              _controller.addError(new HttpException(
-                  "Content size below specified contentLength. "
-                  " $_bytesWritten bytes written while expected "
-                  "$expectedTransferLength."));
-            }
-          }
-          _controller.close();
-        },
-        unsubscribeOnError: true);
-    return _controller.stream;
-  }
-}
 
 // Extends StreamConsumer as this is an internal type, only used to pipe to.
 class _HttpOutgoing implements StreamConsumer<List<int>, dynamic> {
-  final _DataValidatorTransformer _validator = new _DataValidatorTransformer();
   Function _onStream;
   final Completer _consumeCompleter = new Completer();
 
   Future onStream(Future callback(Stream<List<int>> stream)) {
     _onStream = callback;
     return _consumeCompleter.future;
   }
 
-  void setTransferLength(int transferLength) {
-    _validator.expectedTransferLength = transferLength;
-  }
-
   Future consume(Stream<List<int>> stream) {
-    _onStream(stream.transform(_validator))
+    _onStream(stream)
         .then((_) => _consumeCompleter.complete(),
               onError: _consumeCompleter.completeError);
     // Use .then to ensure a Future branch.
     return _consumeCompleter.future.then((_) => this);
   }
 }
 
 
 class _HttpClientConnection {
   final String key;
@@ skipping 820 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;
 }