Clean up HttpHeaders to always have them in a consistent state.

sdk/lib/io/http_headers.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;
 
 class _HttpHeaders implements HttpHeaders {
+  final Map<String, List<String>> _headers;
+  final String protocolVersion;
+
+  bool _mutable = true;  // Are the headers currently mutable?
+  List<String> _noFoldingHeaders;
+
+  int _contentLength = -1;
+  bool _persistentConnection = true;
+  bool _chunkedTransferEncoding = false;
+  String _host;
+  int _port;
+
   _HttpHeaders(String this.protocolVersion)
-      : _headers = new HashMap<String, List<String>>();
+      : _headers = new HashMap<String, List<String>>() {
+    if (protocolVersion == "1.0") {
+      _persistentConnection = false;
+    }
+  }
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
   }
 
   String value(String name) {
     name = name.toLowerCase();
     List<String> values = _headers[name];
     if (values == null) return null;
@@ skipping 43 matching lines @@
 
   void forEach(void f(String name, List<String> values)) {
     _headers.forEach(f);
   }
 
   void noFolding(String name) {
     if (_noFoldingHeaders == null) _noFoldingHeaders = new List<String>();
     _noFoldingHeaders.add(name);
   }
 
-  bool get persistentConnection {
-    List<String> connection = _headers[HttpHeaders.CONNECTION];
-    if (protocolVersion == "1.1") {
-      if (connection == null) return true;
-      return !connection.any((value) => value.toLowerCase() == "close");
-    } else {
-      if (connection == null) return false;
-      return connection.any((value) => value.toLowerCase() == "keep-alive");
-    }
-  }
+  bool get persistentConnection => _persistentConnection;
 
   void set persistentConnection(bool persistentConnection) {
     _checkMutable();
-    // Determine the value of the "Connection" header.
-    remove(HttpHeaders.CONNECTION, "close");
-    remove(HttpHeaders.CONNECTION, "keep-alive");
-    if (protocolVersion == "1.1" && !persistentConnection) {
-      add(HttpHeaders.CONNECTION, "close");
-    } else if (protocolVersion == "1.0" && persistentConnection) {
-      add(HttpHeaders.CONNECTION, "keep-alive");
+    if (persistentConnection == _persistentConnection) return;
+    if (persistentConnection) {
+      if (protocolVersion == "1.1") {
+        remove(HttpHeaders.CONNECTION, "close");
+      } else {
+        if (_contentLength == -1) {
+          throw new HttpException(
+              "Trying to set 'Connection: Keep-Alive' on HTTP 1.0 headers with "
+              "no ContentLength");
+        }
+        add(HttpHeaders.CONNECTION, "keep-alive");
+      }
+    } else {
+      if (protocolVersion == "1.1") {
+        add(HttpHeaders.CONNECTION, "close");
+      } else {
+        remove(HttpHeaders.CONNECTION, "keep-alive");
+      }
     }
+    _persistentConnection = persistentConnection;
   }
 
   int get contentLength => _contentLength;
 
   void set contentLength(int contentLength) {
     _checkMutable();
+    if (protocolVersion == "1.0" &&
+        persistentConnection &&
+        contentLength == -1) {
+      throw new HttpException(
+          "Trying to clear ContentLength on HTTP 1.0 headers with "
+          "'Connection: Keep-Alive' set");
+    }
     _contentLength = contentLength;
     if (_contentLength >= 0) {
+      if (chunkedTransferEncoding) chunkedTransferEncoding = false;
       _set(HttpHeaders.CONTENT_LENGTH, contentLength.toString());
     } else {
       removeAll(HttpHeaders.CONTENT_LENGTH);
     }
   }
 
   bool get chunkedTransferEncoding => _chunkedTransferEncoding;
 
   void set chunkedTransferEncoding(bool chunkedTransferEncoding) {
     _checkMutable();
-    _chunkedTransferEncoding = chunkedTransferEncoding;
-    List<String> values = _headers[HttpHeaders.TRANSFER_ENCODING];
-    if ((values == null || values[values.length - 1] != "chunked") &&
-        chunkedTransferEncoding) {
-      // Headers does not specify chunked encoding - add it if set.
+    if (chunkedTransferEncoding && protocolVersion == "1.0") {
+      throw new HttpException(
+          "Trying to set 'Transfer-Encoding: Chunked' on HTTP 1.0 headers");
+    }
+    if (chunkedTransferEncoding == _chunkedTransferEncoding) return;
+    if (chunkedTransferEncoding) {
+      List<String> values = _headers[HttpHeaders.TRANSFER_ENCODING];
+      if ((values == null || values.last != "chunked")) {
+        // Headers does not specify chunked encoding - add it if set.
         _addValue(HttpHeaders.TRANSFER_ENCODING, "chunked");
-    } else if (!chunkedTransferEncoding) {
+      }
+      contentLength = -1;
+    } else {
       // Headers does specify chunked encoding - remove it if not set.
       remove(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
+    _chunkedTransferEncoding = chunkedTransferEncoding;
   }
 
   String get host => _host;
 
   void set host(String host) {
     _checkMutable();
     _host = host;
     _updateHostHeader();
   }
 
@@ skipping 136 matching lines @@
               _port = int.parse(value.substring(pos + 1));
             } on FormatException catch (e) {
               _port = null;
             }
           }
         }
         _set(HttpHeaders.HOST, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
+    } else if (name == HttpHeaders.CONNECTION) {
+      var lowerCaseValue = value.toLowerCase();
+      if (lowerCaseValue == 'close') {
+        _persistentConnection = false;
+      } else if (lowerCaseValue == 'keep-alive') {
+        _persistentConnection = true;
+      }
+      _addValue(name, value);
     } else if (name == HttpHeaders.CONTENT_TYPE) {
       _set(HttpHeaders.CONTENT_TYPE, value);
     } else {
       _addValue(name, value);
     }
   }
 
   void _addValue(String name, Object value) {
     List<String> values = _headers[name];
     if (values == null) {
@@ skipping 26 matching lines @@
 
   _foldHeader(String name) {
     if (name == HttpHeaders.SET_COOKIE ||
         (_noFoldingHeaders != null &&
          _noFoldingHeaders.indexOf(name) != -1)) {
       return false;
     }
     return true;
   }
 
-  void _synchronize() {
-    // If the content length is not known make sure chunked transfer
-    // encoding is used for HTTP 1.1.
-    if (contentLength < 0) {
-      if (protocolVersion == "1.0") {
-        persistentConnection = false;
-      } else {
-        chunkedTransferEncoding = true;
-      }
-    }
-    // If a Transfer-Encoding header field is present the
-    // Content-Length header MUST NOT be sent (RFC 2616 section 4.4).
-    if (chunkedTransferEncoding &&
-        contentLength >= 0 &&
-        protocolVersion == "1.1") {
-      contentLength = -1;
-    }
-  }
-
   void _finalize() {
-    _synchronize();
     _mutable = false;
   }
 
   int _write(Uint8List buffer, int offset) {
     void write(List<int> bytes) {
       int len = bytes.length;
       for (int i = 0; i < len; i++) {
         buffer[offset + i] = bytes[i];
       }
       offset += len;
@@ skipping 101 matching lines @@
         if (done()) return;
         expect(";");
       }
     }
     List<String> values = _headers[HttpHeaders.COOKIE];
     if (values != null) {
       values.forEach((headerValue) => parseCookieString(headerValue));
     }
     return cookies;
   }
-
-
-  bool _mutable = true;  // Are the headers currently mutable?
-  Map<String, List<String>> _headers;
-  List<String> _noFoldingHeaders;
-
-  int _contentLength = -1;
-  bool _chunkedTransferEncoding = false;
-  final String protocolVersion;
-  String _host;
-  int _port;
 }
 
 
 class _HeaderValue implements HeaderValue {
   String _value;
   _UnmodifiableMap<String, String> _parameters;
 
   _HeaderValue([String this._value = "", Map<String, String> parameters]) {
     if (parameters != null) {
       _parameters =
@@ skipping 341 matching lines @@
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
   void forEach(void f(K key, V value)) => _map.forEach(f);
   Iterable<K> get keys => _map.keys;
   Iterable<V> get values => _map.values;
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }