Change the HTTP header field names to lowercase

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 {
   _HttpHeaders(String this.protocolVersion)
       : _headers = new Map<String, List<String>>();
 
@@ skipping 51 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 = this[HttpHeaders.CONNECTION];
+    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");
     }
   }
 
   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");
     }
   }
 
   int get contentLength => _contentLength;
 
   void set contentLength(int contentLength) {
     _checkMutable();
     _contentLength = contentLength;
     if (_contentLength >= 0) {
-      _set("content-length", contentLength.toString());
+      _set(HttpHeaders.CONTENT_LENGTH, contentLength.toString());
     } else {
-      removeAll("content-length");
+      removeAll(HttpHeaders.CONTENT_LENGTH);
     }
   }
 
   bool get chunkedTransferEncoding => _chunkedTransferEncoding;
 
   void set chunkedTransferEncoding(bool chunkedTransferEncoding) {
     _checkMutable();
     _chunkedTransferEncoding = chunkedTransferEncoding;
-    List<String> values = _headers["transfer-encoding"];
-    if (values == null || values[values.length - 1] != "chunked") {
+    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) _addValue("transfer-encoding", "chunked");
-    } else {
+        _addValue(HttpHeaders.TRANSFER_ENCODING, "chunked");
+    } else if (!chunkedTransferEncoding) {
       // Headers does specify chunked encoding - remove it if not set.
-      if (!chunkedTransferEncoding) remove("transfer-encoding", "chunked");
+      remove(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
   }
 
   String get host => _host;
 
   void set host(String host) {
     _checkMutable();
     _host = host;
     _updateHostHeader();
   }
 
   int get port => _port;
 
   void set port(int port) {
     _checkMutable();
     _port = port;
     _updateHostHeader();
   }
 
   DateTime get ifModifiedSince {
-    List<String> values = _headers["if-modified-since"];
+    List<String> values = _headers[HttpHeaders.IF_MODIFIED_SINCE];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } on Exception catch (e) {
         return null;
       }
     }
     return null;
   }
 
   void set ifModifiedSince(DateTime ifModifiedSince) {
     _checkMutable();
     // Format "ifModifiedSince" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(ifModifiedSince.toUtc());
-    _set("if-modified-since", formatted);
+    _set(HttpHeaders.IF_MODIFIED_SINCE, formatted);
   }
 
   DateTime get date {
-    List<String> values = _headers["date"];
+    List<String> values = _headers[HttpHeaders.DATE];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } on Exception catch (e) {
         return null;
       }
     }
     return null;
   }
 
   void set date(DateTime date) {
     _checkMutable();
     // Format "DateTime" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(date.toUtc());
     _set("date", formatted);
   }
 
   DateTime get expires {
-    List<String> values = _headers["expires"];
+    List<String> values = _headers[HttpHeaders.EXPIRES];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } on Exception catch (e) {
         return null;
       }
     }
     return null;
   }
 
   void set expires(DateTime expires) {
     _checkMutable();
     // Format "Expires" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(expires.toUtc());
-    _set("expires", formatted);
+    _set(HttpHeaders.EXPIRES, formatted);
   }
 
   ContentType get contentType {
     var values = _headers["content-type"];
     if (values != null) {
       return new ContentType.fromString(values[0]);
     } else {
       return new ContentType();
     }
   }
 
   void set contentType(ContentType contentType) {
     _checkMutable();
-    _set("content-type", contentType.toString());
+    _set(HttpHeaders.CONTENT_TYPE, contentType.toString());
   }
 
   void _add(String name, Object value) {
     var lowerCaseName = name.toLowerCase();
     // TODO(sgjesse): Add immutable state throw HttpException is immutable.
-    if (lowerCaseName == "content-length") {
+    if (lowerCaseName == HttpHeaders.CONTENT_LENGTH) {
       if (value is int) {
         contentLength = value;
       } else if (value is String) {
         contentLength = int.parse(value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
-    } else if (lowerCaseName == "transfer-encoding") {
+    } else if (lowerCaseName == HttpHeaders.TRANSFER_ENCODING) {
       if (value == "chunked") {
         chunkedTransferEncoding = true;
       } else {
         _addValue(lowerCaseName, value);
       }
-    } else if (lowerCaseName == "date") {
+    } else if (lowerCaseName == HttpHeaders.DATE) {
       if (value is DateTime) {
         date = value;
       } else if (value is String) {
-        _set("date", value);
+        _set(HttpHeaders.DATE, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
-    } else if (lowerCaseName == "expires") {
+    } else if (lowerCaseName == HttpHeaders.EXPIRES) {
       if (value is DateTime) {
         expires = value;
       } else if (value is String) {
-        _set("expires", value);
+        _set(HttpHeaders.EXPIRES, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
-    } else if (lowerCaseName == "if-modified-since") {
+    } else if (lowerCaseName == HttpHeaders.IF_MODIFIED_SINCE) {
       if (value is DateTime) {
         ifModifiedSince = value;
       } else if (value is String) {
-        _set("if-modified-since", value);
+        _set(HttpHeaders.IF_MODIFIED_SINCE, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
-    } else if (lowerCaseName == "host") {
+    } else if (lowerCaseName == HttpHeaders.HOST) {
       if (value is String) {
         int pos = (value as String).indexOf(":");
         if (pos == -1) {
           _host = value;
           _port = HttpClient.DEFAULT_HTTP_PORT;
         } else {
           if (pos > 0) {
             _host = (value as String).substring(0, pos);
           } else {
             _host = null;
           }
           if (pos + 1 == value.length) {
             _port = HttpClient.DEFAULT_HTTP_PORT;
           } else {
             try {
               _port = int.parse(value.substring(pos + 1));
             } on FormatException catch (e) {
               _port = null;
             }
           }
         }
-        _set("host", value);
+        _set(HttpHeaders.HOST, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
-    } else if (lowerCaseName == "content-type") {
-      _set("content-type", value);
+    } else if (lowerCaseName == HttpHeaders.CONTENT_TYPE) {
+      _set(HttpHeaders.CONTENT_TYPE, value);
     } else {
         _addValue(lowerCaseName, value);
     }
   }
 
   void _addValue(String name, Object value) {
     List<String> values = _headers[name];
     if (values == null) {
       values = new List<String>();
       _headers[name] = values;
@@ skipping 16 matching lines @@
     if (!_mutable) throw new HttpException("HTTP headers are not mutable");
   }
 
   _updateHostHeader() {
     bool defaultPort = _port == null || _port == HttpClient.DEFAULT_HTTP_PORT;
     String portPart = defaultPort ? "" : ":$_port";
     _set("host", "$host$portPart");
   }
 
   _foldHeader(String name) {
-    if (name == "set-cookie" ||
+    if (name == HttpHeaders.SET_COOKIE ||
         (_noFoldingHeaders != null &&
          _noFoldingHeaders.indexOf(name) != -1)) {
       return false;
     }
     return true;
   }
 
   void _finalize() {
     // If the content length is not known make sure chunked transfer
     // encoding is used for HTTP 1.1.
@@ skipping 135 matching lines @@
         skipWS();
         expect("=");
         skipWS();
         String value = parseValue();
         cookies.add(new _Cookie(name, value));
         skipWS();
         if (done()) return;
         expect(";");
       }
     }
-    List<String> values = this["cookie"];
+    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;
@@ skipping 172 matching lines @@
 
   String _primaryType = "";
   String _subType = "";
 }
 
 
 class _Cookie implements Cookie {
   _Cookie([String this.name, String this.value]);
 
   _Cookie.fromSetCookieValue(String value) {
-    // Parse the Set-Cookie header value.
+    // Parse the 'set-cookie' header value.
     _parseSetCookieValue(value);
   }
 
-  // Parse a Set-Cookie header value according to the rules in RFC 6265.
+  // Parse a 'set-cookie' header value according to the rules in RFC 6265.
   void _parseSetCookieValue(String s) {
     int index = 0;
 
     bool done() => index == s.length;
 
     String parseName() {
       int start = index;
       while (!done()) {
         if (s[index] == "=") break;
         index++;
@@ skipping 100 matching lines @@
 
   String name;
   String value;
   DateTime expires;
   int maxAge;
   String domain;
   String path;
   bool httpOnly = false;
   bool secure = false;
 }