Make the parameters map of the HTTP HeaderValue unmodifiable

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 457 matching lines @@
   final String protocolVersion;
   String _host;
   int _port;
 }
 
 
 class _HeaderValue implements HeaderValue {
   String _value;
   Map<String, String> _parameters;
 
-  _HeaderValue([String this._value = "", this._parameters]);
+  _HeaderValue([String this._value = "", Map<String, String> parameters]) {
+    if (parameters != null) {
+      _parameters =
+          new _UnmodifiableMap(new Map<String, String>.from(parameters));
+    }
+  }
 
   static _HeaderValue parse(String value, {parameterSeparator: ";"}) {
     // Parse the string.
     var result = new _HeaderValue();
     result._parse(value, parameterSeparator);
     return result;
   }
 
   String get value => _value;
 
+  void _ensureParameters() {
+    if (_parameters == null) {
+      _parameters = new _UnmodifiableMap(new Map<String, String>());
+    }
+  }
+
   Map<String, String> get parameters {
-    if (_parameters == null) _parameters = new Map<String, String>();
+    _ensureParameters();
     return _parameters;
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write(_value);
     if (parameters != null && parameters.length > 0) {
       _parameters.forEach((String name, String value) {
         sb.write("; ");
         sb.write(name);
@@ skipping 32 matching lines @@
         throw new HttpException("Failed to parse header value");
       }
       index++;
     }
 
     void maybeExpect(String expected) {
       if (s[index] == expected) index++;
     }
 
     void parseParameters() {
-      _parameters = new Map<String, String>();
+      var parameters = new Map<String, String>();
+      _parameters = new _UnmodifiableMap(parameters);
 
       String parseParameterName() {
         int start = index;
         while (!done()) {
           if (s[index] == " " || s[index] == "\t" || s[index] == "=") break;
           index++;
         }
         return s.substring(start, index).toLowerCase();
       }
 
@@ skipping 23 matching lines @@
       }
 
       while (!done()) {
         skipWS();
         if (done()) return;
         String name = parseParameterName();
         skipWS();
         expect("=");
         skipWS();
         String value = parseParameterValue();
-        _parameters[name] = value;
+        parameters[name] = value;
         skipWS();
         if (done()) return;
         expect(parameterSeparator);
       }
     }
 
     skipWS();
     _value = parseValue();
     skipWS();
     if (done()) return;
     maybeExpect(parameterSeparator);
     parseParameters();
   }
 }
 
 
 class _ContentType extends _HeaderValue implements ContentType {
   String _primaryType = "";
   String _subType = "";
 
   _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";;
+    _value = "$_primaryType/$_subType";
     if (parameters != null) {
+      _ensureParameters();
       parameters.forEach((String key, String value) {
-        this.parameters[key.toLowerCase()] = value.toLowerCase();
+        this._parameters._map[key.toLowerCase()] = value.toLowerCase();
       });
     }
     if (charset != null) {
-      this.parameters["charset"] = charset.toLowerCase();
+      _ensureParameters();
+      this._parameters._map["charset"] = charset.toLowerCase();
     }
   }
 
   _ContentType._();
 
   static _ContentType parse(String value) {
     var result = new _ContentType._();
     result._parse(value, ";");
     int index = result._value.indexOf("/");
     if (index == -1 || index == (result._value.length - 1)) {
       result._primaryType = result._value.trim().toLowerCase();
       result._subType = "";
     } else {
-      result._primaryType = result._value.substring(0, index).trim().toLowerCase();
+      result._primaryType =
+          result._value.substring(0, index).trim().toLowerCase();
       result._subType = result._value.substring(index + 1).trim().toLowerCase();
     }
     return result;
   }
 
   String get mimeType => '$primaryType/$subType';
 
   String get primaryType => _primaryType;
 
   String get subType => _subType;
@@ skipping 124 matching lines @@
 
   String name;
   String value;
   DateTime expires;
   int maxAge;
   String domain;
   String path;
   bool httpOnly = false;
   bool secure = false;
 }
+
+
+class _UnmodifiableMap<K, V> implements Map<K, V> {
+  final Map _map;
+  const _UnmodifiableMap(this._map);
+
+  bool containsValue(Object value) => _map.containsValue(value);
+  bool containsKey(Object key) => _map.containsKey(key);
+  V operator [](Object key) => _map[key];
+  void operator []=(K key, V value) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+  V putIfAbsent(K key, V ifAbsent()) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+  addAll(Map other) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+  V remove(Object key) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+  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;
+}