Use a list of Uint8List-views instead of a BytesBuilder, to build up websocket messages.

sdk/lib/io/websocket_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 String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 // Matches _WebSocketOpcode.
 class _WebSocketMessageType {
@@ skipping 51 matching lines @@
   int _remainingPayloadBytes = -1;
   int _unmaskingIndex = 0;
   int _currentMessageType = _WebSocketMessageType.NONE;
   int closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
   String closeReason = "";
 
   EventSink _eventSink;
 
   final bool _serverSide;
   final List _maskingBytes = new List(4);
-  final BytesBuilder _payload = new BytesBuilder();
+  final List<Uint8List> _payloads = new List<Uint8List>();
 
   _WebSocketProtocolTransformer([this._serverSide = false]);
 
   Stream bind(Stream stream) {
     return new Stream.eventTransformed(
         stream,
         (EventSink eventSink) {
           if (_eventSink != null) {
             throw new StateError("WebSocket transformer already used.");
           }
           _eventSink = eventSink;
           return this;
         });
   }
 
   void addError(Object error, [StackTrace stackTrace]) =>
       _eventSink.addError(error, stackTrace);
 
   void close() => _eventSink.close();
 
+  Uint8List _takePayload() {
+    if (_payloads.length == 0) return new Uint8List(0);

[kasperl, 2014/01/29 11:10:44]

Do you have to create a new one here? Cache an empty list for this case if it's
important?

[Anders Johnsen, 2014/01/29 14:23:40]

The empty-list case is very rare, and not something we particular want to
optimize for.

+    if (_payloads.length == 1) {
+      Uint8List result = _payloads.single;
+      _payloads.clear();
+      return result;
+    }
+    int length = 0;
+    for (Uint8List payload in _payloads) {
+      length += payload.length;
+    }
+    Uint8List result = new Uint8List(length);
+    int offset = 0;
+    for (Uint8List payload in _payloads) {
+      result.setRange(offset, offset + payload.length, payload);
+      offset += payload.length;
+    }
+    _payloads.clear();
+    return result;
+  }
+
   /**
    * Process data received from the underlying communication channel.
    */
   void add(Uint8List buffer) {
     int count = buffer.length;
     int index = 0;
     int lastIndex = count;
     if (_state == CLOSED) {
       throw new WebSocketException("Data on closed connection");
     }
@@ skipping 65 matching lines @@
           }
         } else {
           assert(_state == PAYLOAD);
           // The payload is not handled one byte at a time but in blocks.
           int payloadLength = min(lastIndex - index, _remainingPayloadBytes);
           _remainingPayloadBytes -= payloadLength;
           // Unmask payload if masked.
           if (_masked) {
             _unmask(index, payloadLength, buffer);
           }
-          // Control frame and data frame share _payload builder.
-          _payload.add(new Uint8List.view(buffer.buffer, index, payloadLength));
+          // Control frame and data frame share _payloads.
+          _payloads.add(
+              new Uint8List.view(buffer.buffer, index, payloadLength));
           index += payloadLength;
           if (_isControlFrame()) {
             if (_remainingPayloadBytes == 0) _controlFrameEnd();
           } else {
             if (_currentMessageType != _WebSocketMessageType.TEXT &&
                 _currentMessageType != _WebSocketMessageType.BINARY) {
                 throw new WebSocketException("Protocol error");
             }
             if (_remainingPayloadBytes == 0) _messageFrameEnd();
           }
@@ skipping 88 matching lines @@
       }
     } else {
       _state = PAYLOAD;
     }
   }
 
   void _messageFrameEnd() {
     if (_fin) {
       switch (_currentMessageType) {
         case _WebSocketMessageType.TEXT:
-          _eventSink.add(UTF8.decode(_payload.takeBytes()));
+          _eventSink.add(UTF8.decode(_takePayload()));
           break;
         case _WebSocketMessageType.BINARY:
-          _eventSink.add(_payload.takeBytes());
+          _eventSink.add(_takePayload());
           break;
       }
       _currentMessageType = _WebSocketMessageType.NONE;
     }
     _prepareForNextFrame();
   }
 
   void _controlFrameEnd() {
     switch (_opcode) {
       case _WebSocketOpcode.CLOSE:
         closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
-        if (_payload.length > 0) {
-          var bytes = _payload.takeBytes();
-          if (bytes.length == 1) {
+        var payload = _takePayload();
+        if (payload.length > 0) {
+          if (payload.length == 1) {
             throw new WebSocketException("Protocol error");
           }
-          closeCode = bytes[0] << 8 | bytes[1];
+          closeCode = payload[0] << 8 | payload[1];
           if (closeCode == WebSocketStatus.NO_STATUS_RECEIVED) {
             throw new WebSocketException("Protocol error");
           }
-          if (bytes.length > 2) {
-            closeReason = UTF8.decode(bytes.sublist(2));
+          if (payload.length > 2) {
+            closeReason = UTF8.decode(payload.sublist(2));
           }
         }
         _state = CLOSED;
         _eventSink.close();
         break;
 
       case _WebSocketOpcode.PING:
-        _eventSink.add(new _WebSocketPing(_payload.takeBytes()));
+        _eventSink.add(new _WebSocketPing(_takePayload()));
         break;
 
       case _WebSocketOpcode.PONG:
-        _eventSink.add(new _WebSocketPong(_payload.takeBytes()));
+        _eventSink.add(new _WebSocketPong(_takePayload()));
         break;
     }
     _prepareForNextFrame();
   }
 
   bool _isControlFrame() {
     return _opcode == _WebSocketOpcode.CLOSE ||
            _opcode == _WebSocketOpcode.PING ||
            _opcode == _WebSocketOpcode.PONG;
   }
@@ skipping 616 matching lines @@
            (code < WebSocketStatus.NORMAL_CLOSURE ||
             code == WebSocketStatus.RESERVED_1004 ||
             code == WebSocketStatus.NO_STATUS_RECEIVED ||
             code == WebSocketStatus.ABNORMAL_CLOSURE ||
             (code > WebSocketStatus.INTERNAL_SERVER_ERROR &&
              code < WebSocketStatus.RESERVED_1015) ||
             (code >= WebSocketStatus.RESERVED_1015 &&
              code < 3000));
   }
 }