Fix URI encoding/decoding of + and space

sdk/lib/uri/encode_decode.dart

 // Copyright (c) 2012, 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.uri;
 
 /**
  * Javascript-like URI encode/decode functions.
  * The documentation here borrows heavily from the original Javascript
  * doumentation on MDN at:
  * https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects
  */
 
 /**
  * A JavaScript-like URI encoder. Encodes Uniform Resource Identifier [uri]
  * by replacing each instance of certain characters by one, two, three, or four
  * escape sequences representing the UTF-8 encoding of the character (will
  * only be four escape sequences for characters composed of two "surrogate"
  * characters). This assumes that [uri] is a complete URI, so does not encode
  * reserved characters that have special meaning in the URI: [:#;,/?:@&=+\$:]
  * It returns the escaped URI.
  */
 String encodeUri(String uri) {
   return _uriEncode(
-    "-_.!~*'()#;,/?:@&=+\$0123456789"
+    "-_.!~*'()#;,/?:@&=\$0123456789"
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", uri);
 }
 
 /**
  * An implementation of JavaScript's decodeURIComponent function.
  * Decodes a Uniform Resource Identifier [uri] previously created by
  * encodeURI or by a similar routine. It replaces each escape sequence
  * in [uri] with the character that it represents. It does not decode
  * escape sequences that could not have been introduced by encodeURI.
  * It returns the unescaped URI.
@@ skipping 37 matching lines @@
 /**
  * This is the internal implementation of JavaScript's encodeURI function.
  * It encodes all characters in the string [text] except for those
  * that appear in [canonical], and returns the escaped string.
  */
 String _uriEncode(String canonical, String text) {
   final String hex = '0123456789ABCDEF';
   var byteToHex = (int v) => '%${hex[v >> 4]}${hex[v&0xf]}';
   StringBuffer result = new StringBuffer();
   for (int i = 0; i < text.length; i++) {
     if (canonical.indexOf(text[i]) >= 0) {

[Lasse Reichstein Nielsen, 2012/12/20 23:24:32]

Ick, that looks slow - indexOf is linear in the canonical string.

[Søren Gjesse, 2012/12/21 08:51:19]

Created a new change to address this.

       result.add(text[i]);
+    } else if (text[i] == " ") {
+      result.add("+");
     } else {
       int ch = text.charCodeAt(i);
       if (ch >= 0xD800 && ch < 0xDC00) {
         // Low surrogate. We expect a next char high surrogate.
         ++i;
         int nextCh = text.length == i ? 0 : text.charCodeAt(i);
         if (nextCh >= 0xDC00 && nextCh < 0xE000) {
           // convert the pair to a U+10000 codepoint
           ch = 0x10000 + ((ch-0xD800) << 10) + (nextCh - 0xDC00);
         } else {
@@ skipping 26 matching lines @@
 /**
  * A JavaScript-like decodeURI function. It unescapes the string [text] and
  * returns the unescaped string.
  */
 String _uriDecode(String text) {
   StringBuffer result = new StringBuffer();
   List<int> codepoints = new List<int>();
   for (int i = 0; i < text.length;) {
     String ch = text[i];
     if (ch != '%') {
-      result.add(ch);
+      if (ch == '+') {
+        result.add(" ");
+      } else {
+        result.add(ch);
+      }
       i++;
     } else {
       codepoints.clear();
       while (ch == '%') {
         if (++i > text.length - 2) {
           throw new ArgumentError('Truncated URI');
         }
         codepoints.add(_hexCharPairToByte(text, i));
         i += 2;
         if (i == text.length)
           break;
         ch = text[i];
       }
       result.add(decodeUtf8(codepoints));
     }
   }
   return result.toString();
 }