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

sdk/lib/io/bytes_builder.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;
 
 /**
  * Builds a list of bytes, allowing bytes and lists of bytes to be added at the
  * end.
  *
@@ skipping 65 matching lines @@
    * Clear the contents of the builder.
    */
   void clear();
 }
 
 
 class _CopyingBytesBuilder implements BytesBuilder {
   // Start with 1024 bytes.
   static const int _INIT_SIZE = 1024;
 
-  static final _emptyList = new Uint8List(0);
-
   int _length = 0;
   Uint8List _buffer;
 
-  _CopyingBytesBuilder([int initialCapacity = 0])
-      : _buffer = (initialCapacity <= 0)
-                      ? _emptyList
-                      : new Uint8List(_pow2roundup(initialCapacity));
-
   void add(List<int> bytes) {
     int bytesLength = bytes.length;
     if (bytesLength == 0) return;
     int required = _length + bytesLength;
-    if (_buffer.length < required) {
-      _grow(required);
+    if (_buffer == null) {
+      int size = _pow2roundup(required);
+      size = max(size, _INIT_SIZE);
+      _buffer = new Uint8List(size);
+    } else if (_buffer.length < required) {
+      // We will create a list in the range of 2-4 times larger than
+      // required.
+      int size = _pow2roundup(required) * 2;
+      var newBuffer = new Uint8List(size);
+      newBuffer.setRange(0, _buffer.length, _buffer);
+      _buffer = newBuffer;
     }
     assert(_buffer.length >= required);
     if (bytes is Uint8List) {
       _buffer.setRange(_length, required, bytes);
     } else {
       for (int i = 0; i < bytesLength; i++) {
         _buffer[_length + i] = bytes[i];
       }
     }
     _length = required;
   }
 
-  void addByte(int byte) {
-    if (_buffer.length == _length) {
-      // The grow algorithm always at least doubles.
-      // If we added one to _length it would quadruple unnecessarily.
-      _grow(_length);
-    }
-    assert(_buffer.length > _length);
-    _buffer[_length] = byte;
-    _length++;
-  }
-
-  void _grow(int required) {
-    // We will create a list in the range of 2-4 times larger than
-    // required.
-    int newSize = required * 2;
-    if (newSize < _INIT_SIZE) {
-      newSize = _INIT_SIZE;
-    } else {
-      newSize = _pow2roundup(newSize);
-    }
-    var newBuffer = new Uint8List(newSize);
-    newBuffer.setRange(0, _buffer.length, _buffer);
-    _buffer = newBuffer;
-  }
+  void addByte(int byte) { add([byte]); }
 
   List<int> takeBytes() {
-    if (_length == 0) return _emptyList;
+    if (_buffer == null) return new Uint8List(0);
     var buffer = new Uint8List.view(_buffer.buffer, 0, _length);
     clear();
     return buffer;
   }
 
   List<int> toBytes() {
-    if (_length == 0) return _emptyList;
+    if (_buffer == null) return new Uint8List(0);
     return new Uint8List.fromList(
         new Uint8List.view(_buffer.buffer, 0, _length));
   }
 
   int get length => _length;
 
   bool get isEmpty => _length == 0;
 
   bool get isNotEmpty => _length != 0;
 
   void clear() {
     _length = 0;
-    _buffer = _emptyList;
+    _buffer = null;
   }
 
-  static int _pow2roundup(int x) {
-    assert(x > 0);
+  int _pow2roundup(int x) {
     --x;
     x |= x >> 1;
     x |= x >> 2;
     x |= x >> 4;
     x |= x >> 8;
     x |= x >> 16;
     return x + 1;
   }
 }
 
 
 class _BytesBuilder implements BytesBuilder {
   int _length = 0;
   final List<Uint8List> _chunks = [];
 
   void add(List<int> bytes) {
     Uint8List typedBytes;
     if (bytes is Uint8List) {
       typedBytes = bytes;
     } else {
       typedBytes = new Uint8List.fromList(bytes);
     }
     _chunks.add(typedBytes);
     _length += typedBytes.length;
   }
 
-  void addByte(int byte) {
-    _chunks.add(new Uint8List(1)..[0] = byte);
-    _length++;
-  }
+  void addByte(int byte) { add([byte]); }
 
   List<int> takeBytes() {
-    if (_length == 0) return _CopyingBytesBuilder._emptyList;
+    if (_chunks.length == 0) return new Uint8List(0);
     if (_chunks.length == 1) {
-      var buffer = _chunks[0];
+      var buffer = _chunks.single;
       clear();
       return buffer;
     }
     var buffer = new Uint8List(_length);
     int offset = 0;
     for (var chunk in _chunks) {
       buffer.setRange(offset, offset + chunk.length, chunk);
       offset += chunk.length;
     }
     clear();
     return buffer;
   }
 
   List<int> toBytes() {
-    if (_length == 0) return _CopyingBytesBuilder._emptyList;
+    if (_chunks.length == 0) return new Uint8List(0);
     var buffer = new Uint8List(_length);
     int offset = 0;
     for (var chunk in _chunks) {
       buffer.setRange(offset, offset + chunk.length, chunk);
       offset += chunk.length;
     }
     return buffer;
   }
 
   int get length => _length;
 
   bool get isEmpty => _length == 0;
 
   bool get isNotEmpty => _length != 0;
 
   void clear() {
     _length = 0;
     _chunks.clear();
   }
 }