Start refactoring of the HTTP header handling

runtime/bin/http_impl.dart

 // Copyright (c) 2012, 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.
 
+class _HttpHeaders implements HttpHeaders {
+  _HttpHeaders() : _headers = new Map<String, List<String>>();
+
+  List<String> operator[](String name) {
+    name = name.toLowerCase();
+    return _headers[name];
+  }
+
+  void add(String name, Object value) {
+    if (value is List) {
+      for (int i = 0; i < value.length; i++) {
+        _add(name, vlaie[i]);
+      }
+    } else {
+      _add(name, value);
+    }
+  }
+
+  void set(String name, Object value) {
+    removeAll(name);
+    add(name, value);
+  }
+
+  void remove(String name, Object value) {
+    name = name.toLowerCase();
+    List<String> values = _headers[name];
+    if (values != null) {
+      int index = values.indexOf(value);
+      if (index != -1) {
+        values.removeRange(index, 1);
+      }
+    }
+  }
+
+  void removeAll(String name) {
+    name = name.toLowerCase();
+    _headers.remove(name);
+  }
+
+  String get host() => _host;
+  void set host(String host) {
+    _host = host;
+    _updateHostHeader();
+  }
+
+  int get port() => _port;
+  void set port(int port) {
+    _port = port;
+    _updateHostHeader();
+  }
+
+  Date get expires() {
+    if (_expires == null) {
+      List<String> values = _headers["expires"];
+      if (values != null) {
+        _expires = _HttpUtils.parseDate(values[0]);
+      }
+    }
+    return _expires;
+  }
+
+  void set expires(Date expires) {
+    _expires = expires;
+    // Format "Expires" header with date in Greenwich Mean Time (GMT).
+    String formatted =
+        _HttpUtils.formatDate(_expires.changeTimeZone(new TimeZone.utc()));
+    _set("expires", formatted);
+  }
+
+  void _add(String name, Object value) {
+    // TODO(sgjesse): Add immutable state throw HttpException is immutable.
+    if (name.toLowerCase() == "expires") {
+      if (value is Date) {
+        expires = value;
+      } else if (value is String) {
+        expires = _HttpUtils.parseDate(value);
+      } else {
+        throw new HttpException("Unexpected type for header named $name");
+      }
+    } else if (name.toLowerCase() == "host") {
+      int pos = value.indexOf(":");
+      if (pos == -1) {
+        _host = value;
+        _port = HttpClient.DEFAULT_HTTP_PORT;
+      } else {
+        _host = value.substring(0, pos);
+        if (pos + 1 == value.length) {
+          _port = HttpClient.DEFAULT_HTTP_PORT;
+        } else {
+          _port = Math.parseInt(value.substring(pos + 1));
+        }
+      }
+      _updateHostHeader();
+    } else {
+      name = name.toLowerCase();
+      List<String> values = _headers[name];
+      if (values == null) {
+        values = new List<String>();
+        _headers[name] = values;
+      }
+      values.add(value.toString());
+    }
+  }
+
+  void _set(String name, String value) {
+    name = name.toLowerCase();
+    List<String> values = new List<String>();
+    _headers[name] = values;
+    values.add(value);
+  }
+
+  _updateHostHeader() {
+    String portPart = _port == HttpClient.DEFAULT_HTTP_PORT ? "" : ":$_port";
+    _set("host", "$host$portPart");
+  }
+
+  _write(_HttpConnectionBase connection) {
+    final COLONSP = const [_CharCode.COLON, _CharCode.SP];
+    final COMMASP = const [_CharCode.COMMA, _CharCode.SP];
+    final CRLF = const [_CharCode.CR, _CharCode.LF];
+
+    // Format headers.
+    _headers.forEach((String name, List<String> values) {
+      List<int> data;
+      data = name.charCodes();
+      connection._write(data);
+      connection._write(COLONSP);
+      for (int i = 0; i < values.length; i++) {
+        if (i > 0) {
+          connection._write(COMMASP);
+        }
+        data = values[i].charCodes();
+        connection._write(data);
+      }
+      connection._write(CRLF);
+    });
+  }
+
+  String toString() {

[Anders Johnsen, 2012/04/16 11:50:46]

Looks good, and yes, let's use \n for line feed here. I do however thing we
should return 'sb.toString()' :)

[Søren Gjesse, 2012/04/16 12:17:31]

Good catch. Added return of sb.toString().

+    StringBuffer sb = new StringBuffer();
+    _headers.forEach((String name, List<String> values) {
+      sb.add(name);
+      sb.add(": ");
+      for (int i = 0; i < values.length; i++) {
+        if (i > 0) {
+          sb.add(": ");
+        }
+        sb.add(values[i]);
+      }
+      sb.add("\n");
+    });
+  }
+
+  Map<String, List<String>> _headers;
+
+  String _host;
+  int _port;
+  Date _expires;
+}
+
+
 class _HttpRequestResponseBase {
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _contentLength = -1,
-        _headers = new Map();
+        _headers = new _HttpHeaders();
 
   int get contentLength() => _contentLength;
-  Map get headers() => _headers;
-
-  void _setHeader(String name, String value) {
-    _headers[name.toLowerCase()] = value;
-  }
+  HttpHeaders get headers() => _headers;
 
   bool _write(List<int> data, bool copyBuffer) {
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
@@ skipping 23 matching lines @@
   bool _writeDone() {
     bool allWritten = true;
     if (_contentLength < 0) {
       // Terminate the content if transfer encoding is chunked.
       allWritten = _httpConnection._write(_Const.END_CHUNKED);
     }
     return allWritten;
   }
 
   bool _writeHeaders() {
-    List<int> data;
-
-    // Format headers.
-    _headers.forEach((String name, String value) {
-      data = name.charCodes();
-      _httpConnection._write(data);
-      data = ": ".charCodes();
-      _httpConnection._write(data);
-      data = value.charCodes();
-      _httpConnection._write(data);
-      _writeCRLF();
-    });
+    _headers._write(_httpConnection);
     // Terminate header.
     return _writeCRLF();
   }
 
   bool _writeHexString(int x) {
     final List<int> hexDigits = [0x30, 0x31, 0x32, 0x33, 0x34,
                                  0x35, 0x36, 0x37, 0x38, 0x39,
                                  0x41, 0x42, 0x43, 0x44, 0x45, 0x46];
     ByteArray hex = new ByteArray(10);
     int index = hex.length;
     while (x > 0) {
       index--;
       hex[index] = hexDigits[x % 16];
       x = x >> 4;
     }
     return _httpConnection._writeFrom(hex, index, hex.length - index);
   }
 
   bool _writeCRLF() {
     final CRLF = const [_CharCode.CR, _CharCode.LF];
     return _httpConnection._write(CRLF);
   }
 
   bool _writeSP() {
     final SP = const [_CharCode.SP];
     return _httpConnection._write(SP);
   }
 
   _HttpConnectionBase _httpConnection;
-  Map<String, String> _headers;
+  _HttpHeaders _headers;
 
   // Length of the content body. If this is set to -1 (default value)
   // when starting to send data chunked transfer encoding will be
   // used.
   int _contentLength;
 }
 
 
 // Parsed HTTP request providing information on the HTTP headers.
 class _HttpRequest extends _HttpRequestResponseBase implements HttpRequest {
@@ skipping 12 matching lines @@
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri, String version) {
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
   void _onHeaderReceived(String name, String value) {
-    _setHeader(name, value);
+    _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
     // Prepare for receiving data.
     _buffer = new _BufferList();
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
@@ skipping 68 matching lines @@
     if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
   String get reasonPhrase() => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _reasonPhrase = reasonPhrase;
   }
 
-  Date get expires() => _expires;
-  void set expires(Date expires) {
-    if (_outputStream != null) throw new HttpException("Header already sent");
-    _expires = expires;
-    // Format "Expires" header with date in Greenwich Mean Time (GMT).
-    String formatted =
-        _HttpUtils.formatDate(_expires.changeTimeZone(new TimeZone.utc()));
-    _setHeader("Expires", formatted);
-  }
-
-  // Set a header on the response. NOTE: If the same header is set
-  // more than once only the last one will be part of the response.
-  void setHeader(String name, String value) {
-    if (_outputStream != null) return new HttpException("Header already sent");
-    if (name.toLowerCase() == "expires") {
-      expires = _HttpUtils.parseDate(value);
-    } else {
-      _setHeader(name, value);
-    }
-  }
-
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
       // Ensure that headers are written.
       if (_state == START) {
         _writeHeader();
       }
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
@@ skipping 103 matching lines @@
     _writeSP();
     data = _statusCode.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     data = reasonPhrase.charCodes();
     _httpConnection._write(data);
     _writeCRLF();
 
     // Determine the value of the "Connection" header.
     if (_protocolVersion == "1.1" && !_persistentConnection) {
-      setHeader("Connection", "close");
+      _headers.set("Connection", "close");
     } else if (_protocolVersion == "1.0" && _persistentConnection) {
-      setHeader("Connection", "keep-alive");
+      _headers.set("Connection", "keep-alive");
     }
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
-      setHeader("Content-Length", _contentLength.toString());
+      _headers.set("Content-Length", _contentLength.toString());
     } else {
-      setHeader("Transfer-Encoding", "chunked");
+      _headers.set("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADERS_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
   String _protocolVersion;
-  Date _expires;
   bool _persistentConnection;
   _HttpOutputStream _outputStream;
   int _state;
   Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
@@ skipping 327 matching lines @@
         _state = START {
     _connection = connection;
     // Default GET requests to have no content.
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) => _contentLength = contentLength;
 
-  String get host() => _host;
-  void set host(String host) {
-    _host = host;
-    _updateHostHeader();
-  }
-
-  int get port() => _port;
-  void set port(int port) {
-    _port = port;
-    _updateHostHeader();
-  }
-
-  void setHeader(String name, String value) {
-    if (_state != START) throw new HttpException("Header already sent");
-    if (name.toLowerCase() == "host") {
-      int pos = value.indexOf(":");
-      if (pos == -1) {
-        _host = value;
-        _port = HttpClient.DEFAULT_HTTP_PORT;
-      } else {
-        _host = value.substring(0, pos);
-        if (pos + 1 == value.length) {
-          _port = HttpClient.DEFAULT_HTTP_PORT;
-        } else {
-          _port = Math.parseInt(value.substring(pos + 1));
-        }
-      }
-      _updateHostHeader();
-      return;
-    }
-    _setHeader(name, value);
-  }
-
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Request closed");
     if (_outputStream == null) {
       // Ensure that headers are written.
       if (_state == START) {
         _writeHeader();
       }
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
-  _updateHostHeader() {
-    String portPart = _port == HttpClient.DEFAULT_HTTP_PORT ? "" : ":$_port";
-    _setHeader("Host", "$host$portPart");
-  }
-
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
@@ skipping 27 matching lines @@
     _writeSP();
     data = _uri.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     _httpConnection._write(_Const.HTTP11);
     _writeCRLF();
 
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
-      setHeader("Content-Length", _contentLength.toString());
+      _headers.set("Content-Length", _contentLength.toString());
     } else {
-      setHeader("Transfer-Encoding", "chunked");
+      _headers.set("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     _writeHeaders();
     _state = HEADERS_SENT;
   }
 
   String _method;
   String _uri;
-  String _host;
-  int _port;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
   int _state;
   Function _streamErrorHandler;
 }
 
 
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
 
   int get statusCode() => _statusCode;
   String get reasonPhrase() => _reasonPhrase;
 
-  Date get expires() {
-    String str = _headers["expires"];
-    if (str == null) return null;
-    return _HttpUtils.parseDate(str);
-  }
-
-  Map get headers() => _headers;
-
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling
   }
 
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
   }
 
   void _onHeaderReceived(String name, String value) {
-    _setHeader(name, value);
+    _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
     _buffer = new _BufferList();
     if (_connection._onResponse != null) {
       _connection._onResponse(this);
     }
   }
 
   void _onDataReceived(List<int> data) {
@@ skipping 242 matching lines @@
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
       String host, int port, String method, String path) {
 
     void _connectionOpened(_SocketConnection socketConn,
                            _HttpClientConnection connection) {
       connection._connectionEstablished(socketConn);
       HttpClientRequest request = connection.open(method, path);
-      request.host = host;
-      request.port = port;
+      request.headers.host = host;
+      request.headers.port = port;
       if (connection._onRequest != null) {
         connection._onRequest(request);
       } else {
         request.outputStream.close();
       }
     }
 
     _HttpClientConnection connection = new _HttpClientConnection(this);
 
     // If there are active connections for this key get the first one
@@ skipping 79 matching lines @@
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }