Fix various problems with inline autocomplete and URLs that change length dur...

net/base/escape.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// 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"
 #include "base/string_util.h"
@@ skipping 88 matching lines @@
      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) {
+                            UnescapeRule::Type rules,
+                            size_t* offset_for_adjustment) {
+  size_t offset_temp = std::wstring::npos;
+  if (!offset_for_adjustment)
+    offset_for_adjustment = &offset_temp;
+  else if (*offset_for_adjustment >= escaped_text.length())
+    *offset_for_adjustment = std::wstring::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;
   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 (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.
              (value > ' ' && (rules & UnescapeRule::URL_SPECIAL_CHARS)) ||
              // Additionally allow control characters if requested.
              (value < ' ' && (rules & UnescapeRule::CONTROL_CHARS)))) {
           // Use the unescaped version of the character.
+          size_t length_before_append = result.length();
           result.push_back(value);
           i += 2;
+
+          // Adjust offset to match length change.
+          if (*offset_for_adjustment != std::string::npos) {
+            if (*offset_for_adjustment > (length_before_append + 2))
+              *offset_for_adjustment -= 2;
+            else if (*offset_for_adjustment > length_before_append)
+              *offset_for_adjustment = std::string::npos;
+          }
         } else {
           // Keep escaped. Append a percent and we'll get the following two
           // digits on the next loops through.
           result.push_back('%');
         }
       } else {
         // Invalid escape sequence, just pass the percent through and continue
         // right after it.
         result.push_back('%');
       }
@@ skipping 73 matching lines @@
   if (!base::WideToCodepage(text, codepage,
                             base::OnStringConversionError::SKIP, &encoded))
     return false;
 
   // It's safe to use UTF8ToWide here because Escape should only return
   // alphanumerics and !'()*-._~
   escaped->assign(UTF8ToWide(Escape(encoded, kQueryCharmap, true)));
   return true;
 }
 
-std::wstring UnescapeAndDecodeURLComponent(const std::string& text,
-                                           const char* codepage,
-                                           UnescapeRule::Type rules) {
+std::wstring UnescapeAndDecodeUTF8URLComponent(const std::string& text,
+                                               UnescapeRule::Type rules,
+                                               size_t* offset_for_adjustment) {
   std::wstring result;
-  if (base::CodepageToWide(UnescapeURLImpl(text, rules), codepage,
-                           base::OnStringConversionError::FAIL, &result))
+  size_t original_offset = offset_for_adjustment ? *offset_for_adjustment : 0;
+  if (base::CodepageToWideAndAdjustOffset(
+          UnescapeURLImpl(text, rules, offset_for_adjustment),
+          "UTF-8", base::OnStringConversionError::FAIL, &result,
+          offset_for_adjustment))
     return result;          // Character set looks like it's valid.
-  return UTF8ToWide(text);  // Return the escaped version when it's not.
+
+  // Not valid.  Return the escaped version.  Undo our changes to
+  // |offset_for_adjustment| since we haven't changed the string after all.
+  if (offset_for_adjustment)
+    *offset_for_adjustment = original_offset;
+  return UTF8ToWideAndAdjustOffset(text, offset_for_adjustment);
 }
 
 std::string UnescapeURLComponent(const std::string& escaped_text,
                                  UnescapeRule::Type rules) {
-  return UnescapeURLImpl(escaped_text, 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;
   } kCharsToEscape[] = {
     { '<', "&lt;" },
     { '>', "&gt;" },
@@ skipping 33 matching lines @@
   return result;
 }
 
 std::string EscapeForHTML(const std::string& input) {
   return EscapeForHTMLImpl(input);
 }
 
 std::wstring EscapeForHTML(const std::wstring& input) {
   return EscapeForHTMLImpl(input);
 }