Revert "Make HTTP headers use a growing buffer, not a fixed-size 8K one."

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;
 
 typedef void _BytesConsumer(List<int> bytes);
 
@@ skipping 556 matching lines @@
     if (_deadlineTimer != null) _deadlineTimer.cancel();
     _deadline = d;
 
     if (_deadline == null) return;
     _deadlineTimer = new Timer(_deadline, () {
       _httpRequest._httpConnection.destroy();
     });
   }
 
   void _writeHeader() {
-    BytesBuilder buffer = new _CopyingBytesBuilder(_OUTGOING_BUFFER_SIZE);
+    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++) {
+        buffer[offset + i] = bytes[i];
+      }
+      offset += len;
+    }
 
     // Write status line.
     if (headers.protocolVersion == "1.1") {
-      buffer.add(_Const.HTTP11);
+      write(_Const.HTTP11);
     } else {
-      buffer.add(_Const.HTTP10);
+      write(_Const.HTTP10);
     }
-    buffer.addByte(_CharCode.SP);
-    buffer.add(statusCode.toString().codeUnits);
-    buffer.addByte(_CharCode.SP);
-    buffer.add(reasonPhrase.codeUnits);
-    buffer.addByte(_CharCode.CR);
-    buffer.addByte(_CharCode.LF);
+    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]
@@ skipping 13 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._build(buffer);
-    buffer.addByte(_CharCode.CR);
-    buffer.addByte(_CharCode.LF);
-    Uint8List headerBytes = buffer.takeBytes();
-    _outgoing.setHeader(headerBytes, headerBytes.length);
+    offset = headers._write(buffer, offset);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
+    _outgoing.setHeader(buffer, 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 167 matching lines @@
         if (_httpClientConnection._proxyTunnel) {
           return uriStartingFromPath();
         } else {
           return uri.removeFragment().toString();
         }
       }
     }
   }
 
   void _writeHeader() {
-    BytesBuilder buffer = new _CopyingBytesBuilder(_OUTGOING_BUFFER_SIZE);
+    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++) {
+        buffer[offset + i] = bytes[i];
+      }
+      offset += len;
+    }
 
     // Write the request method.
-    buffer.add(method.codeUnits);
-    buffer.addByte(_CharCode.SP);
+    write(method.codeUnits);
+    buffer[offset++] = _CharCode.SP;
     // Write the request URI.
-    buffer.add(_requestUri().codeUnits);
-    buffer.addByte(_CharCode.SP);
+    write(_requestUri().codeUnits);
+    buffer[offset++] = _CharCode.SP;
     // Write HTTP/1.1.
-    buffer.add(_Const.HTTP11);
-    buffer.addByte(_CharCode.CR);
-    buffer.addByte(_CharCode.LF);
+    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)..write("=")..write(cookies[i].value);
       }
       headers.add(HttpHeaders.COOKIE, sb.toString());
     }
 
     headers._finalize();
 
     // Write headers.
-    headers._build(buffer);
-    buffer.addByte(_CharCode.CR);
-    buffer.addByte(_CharCode.LF);
-    Uint8List headerBytes = buffer.takeBytes();
-    _outgoing.setHeader(headerBytes, headerBytes.length);
+    offset = headers._write(buffer, offset);
+    buffer[offset++] = _CharCode.CR;
+    buffer[offset++] = _CharCode.LF;
+    _outgoing.setHeader(buffer, offset);
   }
 }
 
 // Used by _HttpOutgoing as a target of a chunked converter for gzip
 // compression.
 class _HttpGZipSink extends ByteConversionSink {
   final _BytesConsumer _consume;
   _HttpGZipSink(this._consume);
 
   void add(List<int> chunk) {
@@ skipping 55 matching lines @@
 
   bool _socketError = false;
 
   _HttpOutboundMessage outbound;
 
   _HttpOutgoing(this.socket);
 
   // Returns either a future or 'null', if it was able to write headers
   // immediately.
   Future writeHeaders({bool drainRequest: true, bool setOutgoing: true}) {
+    Future write() {
+      try {
+        outbound._writeHeader();
+      } catch (_) {
+        // Headers too large.
+        return new Future.error(new HttpException(
+            "Headers size exceeded the of '$_OUTGOING_BUFFER_SIZE'"
+            " bytes"));
+      }
+      return null;
+    }
+
     if (headersWritten) return null;
     headersWritten = true;
     Future drainFuture;
     bool gzip = false;
     if (outbound is _HttpResponse) {
       // Server side.
       _HttpResponse response = outbound;
       if (response._httpRequest._httpServer.autoCompress &&
           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;
         }
       }
       if (drainRequest && !response._httpRequest._incoming.hasSubscriber) {
         drainFuture = response._httpRequest.drain().catchError((_) {});
       }
     } else {
       drainRequest = false;
     }
-    if (!ignoreBody) {
-      if (setOutgoing) {
-        int contentLength = outbound.headers.contentLength;
-        if (outbound.headers.chunkedTransferEncoding) {
-          chunked = true;
-          if (gzip) this.gzip = true;
-        } else if (contentLength >= 0) {
-          this.contentLength = contentLength;
-        }
-      }
-      if (drainFuture != null) {
-        return drainFuture.then((_) => outbound._writeHeader());
+    if (ignoreBody) {
+      return write();
+    }
+    if (setOutgoing) {
+      int contentLength = outbound.headers.contentLength;
+      if (outbound.headers.chunkedTransferEncoding) {
+        chunked = true;
+        if (gzip) this.gzip = true;
+      } else if (contentLength >= 0) {
+        this.contentLength = contentLength;
       }
     }
-    outbound._writeHeader();
-    return null;
+    if (drainFuture != null) {
+      return drainFuture.then((_) => write());
+    }
+    return write();
   }
 
 
   Future addStream(Stream<List<int>> stream) {
     if (_socketError) {
       stream.listen(null).cancel();
       return new Future.value(outbound);
     }
     if (ignoreBody) {
       stream.drain().catchError((_) {});
@@ skipping 149 matching lines @@
     if (future != null) {
       return _closeFuture = future.whenComplete(finalize);
     }
     return _closeFuture = finalize();
   }
 
   Future<Socket> get done => _doneCompleter.future;
 
   void setHeader(List<int> data, int length) {
     assert(_length == 0);
+    assert(data.length == _OUTGOING_BUFFER_SIZE);
     _buffer = data;
     _length = length;
   }
 
   void set gzip(bool value) {
     _gzip = value;
     if (_gzip) {
       _gzipBuffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
       assert(_gzipSink == null);
       _gzipSink = new ZLibEncoder(gzip: true)
@@ skipping 1717 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)';
 }