Add special handling of the content type HTTP header

runtime/bin/http_impl.dart

Index: runtime/bin/http_impl.dart
diff --git a/runtime/bin/http_impl.dart b/runtime/bin/http_impl.dart
index 05c0a8f3907ac8e08d5e94d19a022374a5f9430a..4e19791db6709211d85271658d2ad51a470a1611 100644
--- a/runtime/bin/http_impl.dart
+++ b/runtime/bin/http_impl.dart
@@ -12,6 +12,7 @@ class _HttpHeaders implements HttpHeaders {
 
   String value(String name) {
     name = name.toLowerCase();
+    _syncHeaderValuesCache(name);
     List<String> values = _headers[name];
     if (values == null) return null;
     if (values.length > 1) {
@@ -32,6 +33,7 @@ class _HttpHeaders implements HttpHeaders {
   }
 
   void set(String name, Object value) {
+    name = name.toLowerCase();
     _checkMutable();
     removeAll(name);
     add(name, value);
@@ -47,15 +49,18 @@ class _HttpHeaders implements HttpHeaders {
         values.removeRange(index, 1);
       }
     }
+    _clearHeaderValueCache(name);
   }
 
   void removeAll(String name) {
     _checkMutable();
     name = name.toLowerCase();
     _headers.remove(name);
+    _clearHeaderValueCache(name);
   }
 
   void forEach(void f(String name, List<String> values)) {
+    _syncHeaderValuesCache();
     _headers.forEach(f);
   }
 
@@ -115,6 +120,18 @@ class _HttpHeaders implements HttpHeaders {
     _set("expires", formatted);
   }
 
+  void get contentType() {
+    if (_contentType == null) {
+      var values = _headers["content-type"];
+      if (values != null) {
+        _contentType = new ContentType.fromString(values[0]);
+      } else {
+        _contentType = new ContentType();
+      }
+    }
+    return _contentType;
+  }
+
   void _add(String name, Object value) {
     // TODO(sgjesse): Add immutable state throw HttpException is immutable.
     if (name.toLowerCase() == "date") {
@@ -155,6 +172,9 @@ class _HttpHeaders implements HttpHeaders {
         }
         _set("host", value);
       }
+    } else if (name.toLowerCase() == "content-type") {
+      _set("content-type", value);
+      _contentType = null;
     } else {
       name = name.toLowerCase();
       List<String> values = _headers[name];
@@ -183,11 +203,31 @@ class _HttpHeaders implements HttpHeaders {
     _set("host", "$host$portPart");
   }
 
+  void _syncHeaderValuesCache([String name]) {
+    if (name == null) {
+      if (_contentType != null) {
+        _set("content-type", _contentType.toString());
+      }
+    } else if (name == "content-type" && _contentType != null) {
+      _set("content-type", _contentType.toString());
+    }
+  }
+
+  void _clearHeaderValueCache([String name]) {
+    if (name == null) {
+      _contentType = null;
+    } else if (name == "content-type") {
+      _contentType = null;
+    }
+  }
+
   _write(_HttpConnectionBase connection) {
     final COLONSP = const [_CharCode.COLON, _CharCode.SP];
     final COMMASP = const [_CharCode.COMMA, _CharCode.SP];
     final CRLF = const [_CharCode.CR, _CharCode.LF];
 
+    _syncHeaderValuesCache();
+
     // Format headers.
     _headers.forEach((String name, List<String> values) {
       List<int> data;
@@ -206,6 +246,7 @@ class _HttpHeaders implements HttpHeaders {
   }
 
   String toString() {
+    _syncHeaderValuesCache();
     StringBuffer sb = new StringBuffer();
     _headers.forEach((String name, List<String> values) {
       sb.add(name);
@@ -226,6 +267,168 @@ class _HttpHeaders implements HttpHeaders {
 
   String _host;
   int _port;
+  ContentType _contentType;
+}
+
+
+class _HeaderValue implements HeaderValue {
+  _HeaderValue([String this.value = ""]);
+
+  _HeaderValue.fromString(String value) {
+    // Parse the string.
+    _parse(value);
+  }
+
+  Map<String, String> get parameters() {
+    if (_parameters == null) _parameters = new Map<String, String>();
+    return _parameters;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.add(value);
+    if (parameters != null && parameters.length > 0) {
+      _parameters.forEach((String name, String value) {
+        sb.add("; ");
+        sb.add(name);
+        sb.add("=");
+        sb.add(value);
+      });
+    }
+    return sb.toString();
+  }
+
+  void _parse(String s) {
+    int index = 0;
+
+    bool done() => index == s.length;
+
+    void skipWS() {
+      while (!done()) {
+        if (s[index] != " " && s[index] != "\t") return;
+        index++;
+      }
+    }
+
+    String parseValue() {
+      int start = index;
+      while (!done()) {
+        if (s[index] == " " || s[index] == "\t" || s[index] == ";") break;
+        index++;
+      }
+      return s.substring(start, index).toLowerCase();
+    }
+
+    void expect(String expected) {
+      if (done()) throw new HttpException("Failed to parse header value [$s]");
+      if (s[index] != expected) {
+        throw new HttpException("Failed to parse header value [$s]");
+      }
+      index++;
+    }
+
+    void parseParameters() {
+      _parameters = new Map<String, String>();
+
+      String parseParameterName() {
+        int start = index;
+        while (!done()) {
+          if (s[index] == " " || s[index] == "\t" || s[index] == "=") break;
+          index++;
+        }
+        return s.substring(start, index).toLowerCase();
+      }
+
+      String parseParameterValue() {
+        if (s[index] == "\"") {
+          // Parse quoted value.
+          StringBuffer sb = new StringBuffer();
+          index++;
+          while (!done()) {
+            if (s[index] == "\\") {
+              if (index + 1 == s.length) {
+                throw new HttpException("Failed to parse header value [$s]");
+              }
+              index++;
+            } else if (s[index] == "\"") {
+              index++;
+              break;
+            }
+            sb.add(s[index]);
+            index++;
+          }
+          return sb.toString();
+        } else {
+          // Parse non-quoted value.
+          return parseValue();
+        }
+      }
+
+      while (!done()) {
+        skipWS();
+        if (done()) return;
+        String name = parseParameterName();
+        skipWS();
+        expect("=");
+        skipWS();
+        String value = parseParameterValue();
+        _parameters[name] = value;
+        skipWS();
+        if (done()) return;
+        expect(";");
+      }
+    }
+
+    skipWS();
+    value = parseValue();
+    skipWS();
+    if (done()) return;
+    expect(";");
+    parseParameters();
+  }
+
+  String value;
+  Map<String, String> _parameters;
+}
+
+
+class _ContentType extends _HeaderValue implements ContentType {
+  _ContentType([String this._primaryType = "", String this._subType = ""]);
+
+  _ContentType.fromString(String value) : super.fromString(value);
+
+  String get value() => "$_primaryType/$_subType";
+
+  void set value(String s) {
+    int index = s.indexOf("/");
+    if (index == -1 || s.length == index - 1) {

[Mads Ager (google), 2012/05/21 11:49:33]

I agree with Anders about this being: index == (s.length - 1)

However, it will probably work without that check because the substring for the
subType below will be the empty string. :-)

[Søren Gjesse, 2012/05/22 12:47:16]

Of cause you are both right.

+      primaryType = s.trim().toLowerCase();
+    } else {
+      primaryType = s.substring(0, index).trim().toLowerCase();
+      subType = s.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 = "";
 }