Update EscapeExternalHandlerValue to keep '#', '[', and ']'

net/base/escape.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/escape.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 21 matching lines @@
   bool Contains(unsigned char c) const {
     return ((map[c >> 5] & (1 << (c & 31))) != 0);
   }
 
   uint32 map[8];
 };
 
 // Given text to escape and a Charmap defining which values to escape,
 // return an escaped string.  If use_plus is true, spaces are converted
 // to +, otherwise, if spaces are in the charmap, they are converted to
-// %20.
-std::string Escape(const std::string& text, const Charmap& charmap,
-                   bool use_plus) {
+// %20. And if keep_escaped is true, %XX will be kept as it is, otherwise, if
+// '%' is in the charmap, it is converted to %25.
+std::string Escape(const std::string& text,
+                   const Charmap& charmap,
+                   bool use_plus,
+                   bool keep_escaped = false) {
   std::string escaped;
   escaped.reserve(text.length() * 3);
   for (unsigned int i = 0; i < text.length(); ++i) {
     unsigned char c = static_cast<unsigned char>(text[i]);
     if (use_plus && ' ' == c) {
       escaped.push_back('+');
+    } else if (keep_escaped && '%' == c && i + 2 < text.length() &&
+               IsHexDigit(text[i + 1]) && IsHexDigit(text[i + 2])) {
+      escaped.push_back('%');
     } else if (charmap.Contains(c)) {
       escaped.push_back('%');
       escaped.push_back(IntToHex(c >> 4));
       escaped.push_back(IntToHex(c & 0xf));
     } else {
       escaped.push_back(c);
     }
   }
   return escaped;
 }
@@ skipping 257 matching lines @@
   0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
 }};
 
 // non-7bit
 static const Charmap kNonASCIICharmap = {{
   0x00000000L, 0x00000000L, 0x00000000L, 0x00000000L,
   0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
 }};
 
 // Everything except alphanumerics, the reserved characters(;/?:@&=+$,) and
-// !'()*-._~%
+// !'()*-._~#[]
 static const Charmap kExternalHandlerCharmap = {{
-  0xffffffffL, 0x5000080dL, 0x68000000L, 0xb8000001L,
+  0xffffffffL, 0x50000025L, 0x50000000L, 0xb8000001L,
   0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
 }};
 
 }  // namespace
 
 std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
   return Escape(text, kQueryCharmap, use_plus);
 }
 
 std::string EscapePath(const std::string& path) {
   return Escape(path, kPathCharmap, false);
 }
 
 std::string EscapeUrlEncodedData(const std::string& path, bool use_plus) {
   return Escape(path, kUrlEscape, use_plus);
 }
 
 std::string EscapeNonASCII(const std::string& input) {
   return Escape(input, kNonASCIICharmap, false);
 }
 
 std::string EscapeExternalHandlerValue(const std::string& text) {
-  return Escape(text, kExternalHandlerCharmap, false);
+  return Escape(text, kExternalHandlerCharmap, false, true);
 }
 
 void AppendEscapedCharForHTML(char c, std::string* output) {
   AppendEscapedCharForHTMLImpl(c, output);
 }
 
 std::string EscapeForHTML(const std::string& input) {
   return EscapeForHTMLImpl(input);
 }
 
@@ skipping 70 matching lines @@
                        1, kEscapeToChars[i].replacement);
           break;
         }
       }
     }
   }
   return text;
 }
 
 }  // namespace net