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

chrome/browser/net/url_fixer_upper.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 "chrome/browser/net/url_fixer_upper.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 127 matching lines @@
 #if defined(OS_MACOSX)
   static const char kHome[] = "/Users/";
 #else
   static const char kHome[] = "/home/";
 #endif
   return kHome + text.substr(1);
 }
 #endif
 
 // Tries to create a file: URL from |text| if it looks like a filename, even if
-// it doesn't resolve as a valid path or to an existing file.  Returns true
-// with a (possibly invalid) file: URL in |fixed_up_url| for input beginning
-// with a drive specifier or "\\".  Returns false in other cases (including
-// file: URLs: these don't look like filenames), leaving fixed_up_url
-// unchanged.
+// it doesn't resolve as a valid path or to an existing file.  Returns a
+// (possibly invalid) file: URL in |fixed_up_url| for input beginning
+// with a drive specifier or "\\".  Returns the unchanged input in other cases
+// (including file: URLs: these don't look like filenames).
 static string FixupPath(const string& text) {
   DCHECK(!text.empty());
 
   FilePath::StringType filename;
 #if defined(OS_WIN)
   FilePath input_path(UTF8ToWide(text));
   PrepareStringForFileOps(input_path, &filename);
 
   // Fixup Windows-style drive letters, where "C:" gets rewritten to "C|".
   if (filename.length() > 1 && filename[1] == '|')
     filename[1] = ':';
 #elif defined(OS_POSIX)
   FilePath input_path(text);
   PrepareStringForFileOps(input_path, &filename);
   if (filename.length() > 0 && filename[0] == '~')
     filename = FixupHomedir(filename);
 #endif
 
   // Here, we know the input looks like a file.
   GURL file_url = net::FilePathToFileURL(FilePath(filename));
   if (file_url.is_valid()) {
     return WideToUTF8(net::FormatUrl(file_url, std::wstring(), true,
-        UnescapeRule::NORMAL, NULL, NULL));
+        UnescapeRule::NORMAL, NULL, NULL, NULL));
   }
 
   // Invalid file URL, just return the input.
   return text;
 }
 
 // Checks |domain| to see if a valid TLD is already present.  If not, appends
 // |desired_tld| to the domain, and prepends "www." unless it's already present.
-// Then modifies |fixed_up_url| to reflect the changes.
 static void AddDesiredTLD(const string& desired_tld,
                           string* domain) {
   if (desired_tld.empty() || domain->empty())
     return;
 
   // Check the TLD.  If the return value is positive, we already have a TLD, so
   // abort; if the return value is string::npos, there's no valid host (e.g. if
   // the user pasted in garbage for which HistoryURLProvider is trying to
   // suggest an exact match), so adding a TLD makes no sense.  The only useful
   // case is where the return value is 0 (there's a valid host with no known
@@ skipping 65 matching lines @@
     if (last_nondot < domain.length())
       domain.erase(last_nondot);
   }
 
   // Add any user-specified TLD, if applicable.
   AddDesiredTLD(desired_tld, &domain);
 
   url->append(domain);
 }
 
-// Looks for a port number, including initial colon, at port_start.  If
-// something invalid (which cannot be fixed up) is found, like ":foo" or
-// ":7:7", returns false.  Otherwise, removes any extra colons
-// ("::1337" -> ":1337", ":/" -> "/") and returns true.
 static void FixupPort(const string& text,
                       const url_parse::Component& part,
                       string* url) {
   if (!part.is_valid())
     return;
 
-  // Look for non-digit in port and strip if found.
-  string port(text, part.begin, part.len);
-  for (string::iterator i = port.begin(); i != port.end();) {
-    if (IsAsciiDigit(*i))
-      ++i;
-    else
-      i = port.erase(i);
-  }
-
-  if (port.empty())
-    return;  // Nothing to append.
-
+  // We don't fix up the port at the moment.
   url->append(":");
-  url->append(port);
+  url->append(text, part.begin, part.len);
 }
 
 static inline void FixupPath(const string& text,
                              const url_parse::Component& part,
                              string* url) {
   if (!part.is_valid() || part.len == 0) {
     // We should always have a path.
     url->append("/");
     return;
   }
@@ skipping 261 matching lines @@
 
   // Put back the current directory if we saved it.
   if (!base_dir.empty()) {
     file_util::SetCurrentDirectory(old_cur_directory);
   }
 
   if (is_file) {
     GURL file_url = net::FilePathToFileURL(full_path);
     if (file_url.is_valid())
       return WideToUTF8(net::FormatUrl(file_url, std::wstring(),
-          true, UnescapeRule::NORMAL, NULL, NULL));
+          true, UnescapeRule::NORMAL, NULL, NULL, NULL));
     // Invalid files fall through to regular processing.
   }
 
   // Fall back on regular fixup for this input.
 #if defined(OS_WIN)
   string text_utf8 = WideToUTF8(text.value());
 #elif defined(OS_POSIX)
   string text_utf8 = text.value();
 #endif
   return FixupURL(text_utf8, "");
@@ skipping 10 matching lines @@
 }
 wstring URLFixerUpper::FixupURL(const wstring& text,
                                 const wstring& desired_tld) {
   return UTF8ToWide(FixupURL(WideToUTF8(text), WideToUTF8(desired_tld)));
 }
 wstring URLFixerUpper::FixupRelativeFile(const wstring& base_dir,
                                          const wstring& text) {
   return UTF8ToWide(FixupRelativeFile(FilePath::FromWStringHack(base_dir),
                                       FilePath::FromWStringHack(text)));
 }