Use a re-usable buffer for writing HTTP headers. This includes a new header limit of 8192 bytes.

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 _HEADERS_BUFFER_SIZE = 8 * 1024;
+
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
 
   bool fullBodyRead = false;
 
   // Common properties.
   final _HttpHeaders headers;
   bool upgraded = false;
@@ skipping 455 matching lines @@
     return _dataSink.flush();
   }
 
   Future close() {
     return _dataSink.close();
   }
 
   Future<T> get done => _dataSink.done;
 
   Future _writeHeaders({bool drainRequest: true}) {
+    void write() {
+      try {
+        _writeHeader();
+      } catch (error) {
+        // Headers too large.
+        throw new HttpException(
+            "Headers size exceeded the of '$_HEADERS_BUFFER_SIZE' bytes");
+      }
+    }
     if (_headersWritten) return new Future.value();
     _headersWritten = true;
     headers._synchronize();  // Be sure the 'chunked' option is updated.
     _dataSink.encoding = encoding;
     bool isServerSide = this is _HttpResponse;
     if (isServerSide) {
       var response = this;
       if (headers.chunkedTransferEncoding) {
         List acceptEncodings =
             response._httpRequest.headers[HttpHeaders.ACCEPT_ENCODING];
         List contentEncoding = headers[HttpHeaders.CONTENT_ENCODING];
         if (acceptEncodings != null &&
             acceptEncodings
                 .expand((list) => list.split(","))
                 .any((encoding) => encoding.trim().toLowerCase() == "gzip") &&
             contentEncoding == null) {
           headers.set(HttpHeaders.CONTENT_ENCODING, "gzip");
           _asGZip = true;
         }
       }
       if (drainRequest && !response._httpRequest._incoming.hasSubscriber) {
         return response._httpRequest.drain()
             // TODO(ajohnsen): Timeout on drain?
             .catchError((_) {})  // Ignore errors.
-            .then((_) => _writeHeader());
+            .then((_) => write());
       }
     }
-    return new Future.sync(_writeHeader);
+    return new Future.sync(write);
   }
 
   Future _addStream(Stream<List<int>> stream) {
     return _writeHeaders()
         .then((_) {
           int contentLength = headers.contentLength;
           if (_ignoreBody) {
             stream.drain().catchError((_) {});
             return _headersSink.close();
           }
@@ skipping 22 matching lines @@
         headers.chunkedTransferEncoding = false;
         headers.contentLength = 0;
       } else if (!_ignoreBody && headers.contentLength > 0) {
         _headersSink.addError(new HttpException(
             "No content while contentLength was specified to be greater "
             "than 0: ${headers.contentLength}.",
             uri: _uri));
         return _headersSink.done;
       }
     }
-    return _writeHeaders().then((_) => _headersSink.close());
+    return _writeHeaders().whenComplete(_headersSink.close);
   }
 
-  void _writeHeader();  // TODO(ajohnsen): Better name.
+  void _writeHeader();
 }
 
 
 class _HttpOutboundConsumer implements StreamConsumer {
   final _HttpOutboundMessage _outbound;
   StreamController _controller;
   StreamSubscription _subscription;
   Completer _closeCompleter = new Completer();
   Completer _completer;
   bool _socketError = false;
@@ skipping 196 matching lines @@
     if (_deadlineTimer != null) _deadlineTimer.cancel();
     _deadline = d;
 
     if (_deadline == null) return;
     _deadlineTimer = new Timer(_deadline, () {
       _outgoing.socket.destroy();
     });
   }
 
   void _writeHeader() {
-    var builder = new BytesBuilder();
-    writeSP() => builder.add(const [_CharCode.SP]);
-    writeCRLF() => builder.add(const [_CharCode.CR, _CharCode.LF]);
+    Uint8List buffer = _httpRequest._httpConnection._headersBuffer;
+    int offset = 0;
+
+    void write(List<int> bytes) {
+      int len = bytes.length;
+      for (int i = 0; i < len; i++) {
+        buffer[offset + i] = bytes[i];
+      }
+      offset += len;
+    }
 
     // Write status line.
     if (headers.protocolVersion == "1.1") {
-      builder.add(_Const.HTTP11);
+      write(_Const.HTTP11);
     } else {
-      builder.add(_Const.HTTP10);
+      write(_Const.HTTP10);
     }
-    writeSP();
-    builder.add(statusCode.toString().codeUnits);
-    writeSP();
-    builder.add(reasonPhrase.codeUnits);
-    writeCRLF();
+    buffer[offset++] = _CharCode.SP;
+    write(statusCode.toString().codeUnits);
+    buffer[offset++] = _CharCode.SP;
+    write(reasonPhrase.codeUnits);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
 
     var session = _httpRequest._session;
     if (session != null && !session._destroyed) {
       // Mark as not new.
       session._isNew = false;
       // 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) {
           cookies[i].value = session.id;
@@ skipping 12 matching lines @@
     // Add all the cookies set to the headers.
     if (_cookies != null) {
       _cookies.forEach((cookie) {
         headers.add(HttpHeaders.SET_COOKIE, cookie);
       });
     }
 
     headers._finalize();
 
     // Write headers.
-    headers._write(builder);
-    writeCRLF();
-    _headersSink.add(builder.takeBytes());
+    offset = headers._write(buffer, offset);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
+    _headersSink.add(new Uint8List.view(buffer.buffer, 0, offset));
   }
 
   String _findReasonPhrase(int statusCode) {
     if (_reasonPhrase != null) {
       return _reasonPhrase;
     }
 
     switch (statusCode) {
       case HttpStatus.CONTINUE: return "Continue";
       case HttpStatus.SWITCHING_PROTOCOLS: return "Switching Protocols";
@@ skipping 173 matching lines @@
         if (_httpClientConnection._proxyTunnel) {
           return uriStartingFromPath();
         } else {
           return uri.toString();
         }
       }
     }
   }
 
   void _writeHeader() {
-    var builder = new BytesBuilder();
+    Uint8List buffer = _httpClientConnection._headersBuffer;
+    int offset = 0;
 
-    writeSP() => builder.add(const [_CharCode.SP]);
-
-    writeCRLF() => builder.add(const [_CharCode.CR, _CharCode.LF]);
+    void write(List<int> bytes) {
+      int len = bytes.length;
+      for (int i = 0; i < len; i++) {
+        buffer[offset + i] = bytes[i];
+      }
+      offset += len;
+    }
 
     // Write the request method.
-    builder.add(method.codeUnits);
-    writeSP();
+    write(method.codeUnits);
+    buffer[offset++] = _CharCode.SP;
     // Write the request URI.
-    builder.add(_requestUri().codeUnits);
-    writeSP();
+    write(_requestUri().codeUnits);
+    buffer[offset++] = _CharCode.SP;
     // Write HTTP/1.1.
-    builder.add(_Const.HTTP11);
-    writeCRLF();
+    write(_Const.HTTP11);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
 
     // Add the cookies to the headers.
     if (!cookies.isEmpty) {
       StringBuffer sb = new StringBuffer();
       for (int i = 0; i < cookies.length; i++) {
         if (i > 0) sb.write("; ");
         sb.write(cookies[i].name);
         sb.write("=");
         sb.write(cookies[i].value);
       }
       headers.add(HttpHeaders.COOKIE, sb.toString());
     }
 
     headers._finalize();
 
     // Write headers.
-    headers._write(builder);
-    writeCRLF();
-    _headersSink.add(builder.takeBytes());
+    offset = headers._write(buffer, offset);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
+    _headersSink.add(new Uint8List.view(buffer.buffer, 0, offset));
   }
 }
 
 
 class _ChunkedTransformerSink implements EventSink<List<int>> {
 
   int _pendingFooter = 0;
   final EventSink<List<int>> _outSink;
 
   _ChunkedTransformerSink(this._outSink);
@@ skipping 143 matching lines @@
   final String key;
   final Socket _socket;
   final bool _proxyTunnel;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   final _HttpClient _httpClient;
   bool _dispose = false;
   Timer _idleTimer;
   bool closed = false;
   Uri _currentUri;
+  final Uint8List _headersBuffer = new Uint8List(_HEADERS_BUFFER_SIZE);
 
   Completer<_HttpIncoming> _nextResponseCompleter;
   Future _streamFuture;
 
   _HttpClientConnection(String this.key,
                         Socket this._socket,
                         _HttpClient this._httpClient,
                         [this._proxyTunnel = false])
       : _httpParser = new _HttpParser.responseParser() {
     _socket.pipe(_httpParser);
@@ skipping 629 matching lines @@
   static const _CLOSING = 2;
   static const _DETACHED = 3;
 
   int _state = _IDLE;
 
   final Socket _socket;
   final _HttpServer _httpServer;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   Timer _idleTimer;
+  final Uint8List _headersBuffer = new Uint8List(_HEADERS_BUFFER_SIZE);
 
   Future _streamFuture;
 
   _HttpConnection(Socket this._socket, _HttpServer this._httpServer)
       : _httpParser = new _HttpParser.requestParser() {
     _startTimeout();
     _socket.pipe(_httpParser);
     _subscription = _httpParser.listen(
         (incoming) {
           _stopTimeout();
@@ skipping 650 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)';
 }
+
+