Adding some more escaping method....

net/base/escape.cc

 // Copyright (c) 2009 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 <algorithm>
 
 #include "net/base/escape.h"
 
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
@@ skipping 90 matching lines @@
 //   @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 //   P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 //   `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 //   p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  <NBSP>
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
 };
 
-std::string UnescapeURLImpl(const std::string& escaped_text,
-                            UnescapeRule::Type rules,
-                            size_t* offset_for_adjustment) {
+template<typename STR>
+STR UnescapeURLImpl(const STR& escaped_text,
+                    UnescapeRule::Type rules,
+                    size_t* offset_for_adjustment) {
   size_t offset_temp = string16::npos;
   if (!offset_for_adjustment)
     offset_for_adjustment = &offset_temp;
   else if (*offset_for_adjustment >= escaped_text.length())
     *offset_for_adjustment = string16::npos;
 
   // Do not unescape anything, return the |escaped_text| text.
   if (rules == UnescapeRule::NONE)
     return escaped_text;
 
   // The output of the unescaping is always smaller than the input, so we can
   // reserve the input size to make sure we have enough buffer and don't have
   // to allocate in the loop below.
-  std::string result;
+  STR result;
   result.reserve(escaped_text.length());
 
   for (size_t i = 0, max = escaped_text.size(); i < max; ++i) {
-    if (escaped_text[i] == '%' && i + 2 < max) {
-      const std::string::value_type most_sig_digit(escaped_text[i + 1]);
-      const std::string::value_type least_sig_digit(escaped_text[i + 2]);
+    if (static_cast<unsigned char>(escaped_text[i]) >= 128) {
+      // Non ASCII character, append as is.
+      result.push_back(escaped_text[i]);
+      continue;
+    }
+
+    char current_char = static_cast<char>(escaped_text[i]);
+    if (current_char == '%' && i + 2 < max) {
+      const typename STR::value_type most_sig_digit(
+          static_cast<typename STR::value_type>(escaped_text[i + 1]));
+      const typename STR::value_type least_sig_digit(
+          static_cast<typename STR::value_type>(escaped_text[i + 2]));
       if (IsHex(most_sig_digit) && IsHex(least_sig_digit)) {
         unsigned char value = HexToInt(most_sig_digit) * 16 +
             HexToInt(least_sig_digit);
         if (value >= 0x80 ||  // Unescape all high-bit characters.
             // For 7-bit characters, the lookup table tells us all valid chars.
             (kUrlUnescape[value] ||
              // ...and we allow some additional unescaping when flags are set.
              (value == ' ' && (rules & UnescapeRule::SPACES)) ||
              // Allow any of the prohibited but non-control characters when
              // we're doing "special" chars.
@@ skipping 124 matching lines @@
     *offset_for_adjustment = original_offset;
   return WideToUTF16Hack(UTF8ToWideAndAdjustOffset(text,
                                                    offset_for_adjustment));
 }
 
 std::string UnescapeURLComponent(const std::string& escaped_text,
                                  UnescapeRule::Type rules) {
   return UnescapeURLImpl(escaped_text, rules, NULL);
 }
 
+string16 UnescapeURLComponent(const string16& escaped_text,
+                              UnescapeRule::Type rules) {
+  return UnescapeURLImpl(escaped_text, rules, NULL);
+}
+
+
 template <class str>
 void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
   static const struct {
     char key;
-    const char *replacement;
+    const char* replacement;
   } kCharsToEscape[] = {
     { '<', "&lt;" },
     { '>', "&gt;" },
     { '&', "&amp;" },
     { '"', "&quot;" },
     { '\'', "&#39;" },
   };
   size_t k;
   for (k = 0; k < ARRAYSIZE_UNSAFE(kCharsToEscape); ++k) {
     if (c == kCharsToEscape[k].key) {
@@ skipping 26 matching lines @@
   return result;
 }
 
 std::string EscapeForHTML(const std::string& input) {
   return EscapeForHTMLImpl(input);
 }
 
 string16 EscapeForHTML(const string16& input) {
   return EscapeForHTMLImpl(input);
 }
+
+string16 UnescapeForHTML(const string16& input) {
+  static const struct {
+    const wchar_t* ampersand_code;
+    const char replacement;
+  } kEscapeToChars[] = {
+    { L"&lt;", '<' },
+    { L"&gt;", '>' },
+    { L"&amp;", '&' },
+    { L"&quot;", '"' },
+    { L"&#39;", '\''},
+  };
+
+  if (input.find(WideToUTF16(L"&")) == std::string::npos)
+    return input;
+
+  string16 ampersand_chars[ARRAYSIZE_UNSAFE(kEscapeToChars)];
+  string16 text(input);
+  for (string16::iterator iter = text.begin(); iter != text.end(); ++iter) {
+    if (*iter == '&') {
+      // Potential ampersand encode char.
+      size_t index = iter - text.begin();
+      for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEscapeToChars); i++) {
+        if (ampersand_chars[i].empty())
+          ampersand_chars[i] = WideToUTF16(kEscapeToChars[i].ampersand_code);
+        if (text.find(ampersand_chars[i], index) == index) {
+          text.replace(iter, iter + ampersand_chars[i].length(),
+                       1, kEscapeToChars[i].replacement);
+          break;
+        }
+      }
+    }
+  }
+  return text;
+}