Make instances of HeaderValue and ContentType immutable

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 180 matching lines @@
     // Format "Expires" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(expires.toUtc());
     _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();
+      return null;
     }
   }
 
   void set contentType(ContentType contentType) {
     _checkMutable();
     _set(HttpHeaders.CONTENT_TYPE, contentType.toString());
   }
 
   void _add(String name, Object value) {
     var lowerCaseName = name.toLowerCase();
@@ skipping 58 matching lines @@
             }
           }
         }
         _set(HttpHeaders.HOST, value);
       } else {
         throw new HttpException("Unexpected type for header named $name");
       }
     } else if (lowerCaseName == HttpHeaders.CONTENT_TYPE) {
       _set(HttpHeaders.CONTENT_TYPE, value);
     } else {
-        _addValue(lowerCaseName, value);
+      _addValue(lowerCaseName, value);
     }
   }
 
   void _addValue(String name, Object value) {
     List<String> values = _headers[name];
     if (values == null) {
       values = new List<String>();
       _headers[name] = values;
     }
     if (value is DateTime) {
@@ skipping 195 matching lines @@
 
   int _contentLength = -1;
   bool _chunkedTransferEncoding = false;
   final String protocolVersion;
   String _host;
   int _port;
 }
 
 
 class _HeaderValue implements HeaderValue {
-  _HeaderValue([String this.value = ""]);
+  String _value;
+  Map<String, String> _parameters;
 
-  _HeaderValue.fromString(String value, {this.parameterSeparator: ";"}) {
+  _HeaderValue([String this._value = "", this._parameters]);
+
+  _HeaderValue.fromString(String value, {parameterSeparator: ";"}) {
     // Parse the string.
-    _parse(value);
+    _parse(value, parameterSeparator);
   }
 
+  String get value => _value;
+
   Map<String, String> get parameters {
     if (_parameters == null) _parameters = new Map<String, String>();
     return _parameters;
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
-    sb.write(value);
+    sb.write(_value);
     if (parameters != null && parameters.length > 0) {
       _parameters.forEach((String name, String value) {
         sb.write("; ");
         sb.write(name);
         sb.write("=");
         sb.write(value);
       });
     }
     return sb.toString();
   }
 
-  void _parse(String s) {
+  void _parse(String s, String parameterSeparator) {
     int index = 0;
 
     bool done() => index == s.length;
 
     void skipWS() {
       while (!done()) {
         if (s[index] != " " && s[index] != "\t") return;
         index++;
       }
     }
@@ skipping 66 matching lines @@
         skipWS();
         String value = parseParameterValue();
         _parameters[name] = value;
         skipWS();
         if (done()) return;
         expect(parameterSeparator);
       }
     }
 
     skipWS();
-    value = parseValue();
+    _value = parseValue();
     skipWS();
     if (done()) return;
     maybeExpect(parameterSeparator);
     parseParameters();
   }
-
-  String value;
-  String parameterSeparator;
-  Map<String, String> _parameters;
 }
 
 
 class _ContentType extends _HeaderValue implements ContentType {
-  _ContentType(String primaryType, String subType)
-      : _primaryType = primaryType, _subType = subType, super("");
+  _ContentType(String primaryType,
+               String subType,
+               String charset,
+               Map<String, String> parameters)
+      : _primaryType = primaryType, _subType = subType, super("") {
+    if (_primaryType == null) _primaryType = "";
+    if (_subType == null) _subType = "";
+    _value = "$_primaryType/$_subType";;
+    if (parameters != null) {
+      parameters.forEach((String key, String value) {
+        this.parameters[key.toLowerCase()] = value.toLowerCase();
+      });
+    }
+    if (charset != null) {
+      this.parameters["charset"] = charset.toLowerCase();
+    }
+  }
 
-  _ContentType.fromString(String value) : super.fromString(value);
-
-  String get value => "$_primaryType/$_subType";
-
-  void set value(String s) {
-    int index = s.indexOf("/");
-    if (index == -1 || index == (s.length - 1)) {
-      primaryType = s.trim().toLowerCase();
-      subType = "";
+    _ContentType.fromString(String value) : super.fromString(value) {
+    int index = _value.indexOf("/");
+    if (index == -1 || index == (_value.length - 1)) {
+      _primaryType = _value.trim().toLowerCase();
+      _subType = "";
     } else {
-      primaryType = s.substring(0, index).trim().toLowerCase();
-      subType = s.substring(index + 1).trim().toLowerCase();
+      _primaryType = _value.substring(0, index).trim().toLowerCase();
+      _subType = _value.substring(index + 1).trim().toLowerCase();
     }
   }
 
   String get primaryType => _primaryType;
 
-  void set primaryType(String s) {
-    _primaryType = s;
-  }
-
   String get subType => _subType;
 
-  void set subType(String s) {
-    _subType = s;
-  }
-
   String get charset => parameters["charset"];
 
-  void set charset(String s) {
-    parameters["charset"] = s;
-  }
-
   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.
@@ skipping 114 matching lines @@
 
   String name;
   String value;
   DateTime expires;
   int maxAge;
   String domain;
   String path;
   bool httpOnly = false;
   bool secure = false;
 }