Parse input with explicit schemes better. Before, if the user typed "http://...

chrome/browser/autocomplete/autocomplete.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 "chrome/browser/autocomplete/autocomplete.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
@@ skipping 96 matching lines @@
   // to have a scheme.
   const std::wstring parsed_scheme(URLFixerUpper::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
 
   if (parsed_scheme == L"file") {
     // A user might or might not type a scheme when entering a file URL.
     return URL;
   }
 
-  // If the user typed a scheme, determine our available actions based on that.
-  if (parts->scheme.is_valid()) {
+  // If the user typed a scheme, and it's HTTP or HTTPS, we know how to parse it
+  // well enough that we can fall through to the heuristics below.  If it's
+  // something else, we can just determine our action based on what we do with
+  // any input of this scheme.  In theory we could do better with some schemes
+  // (e.g. "ftp" or "view-source") but I'll wait to spend the effort on that
+  // until I run into some cases that really need it.
+  if (parts->scheme.is_nonempty() &&
+      (parsed_scheme != L"http") && (parsed_scheme != L"https")) {
     // See if we know how to handle the URL internally.
     if (URLRequest::IsHandledProtocol(WideToASCII(parsed_scheme)))
       return URL;
 
     // There are also some schemes that we convert to other things before they
     // reach the renderer or else the renderer handles internally without
     // reaching the URLRequest logic.  We thus won't catch these above, but we
     // should still claim to handle them.
     if (LowerCaseEqualsASCII(parsed_scheme, chrome::kViewSourceScheme) ||
         LowerCaseEqualsASCII(parsed_scheme, chrome::kJavaScriptScheme) ||
@@ skipping 17 matching lines @@
       default:
         // We don't know about this scheme.  It's likely to be a search operator
         // like "site:" or "link:".  We classify it as UNKNOWN so the user has
         // the option of treating it as a URL if we're wrong.
         // Note that SegmentURL() is smart so we aren't tricked by "c:\foo" or
         // "www.example.com:81" in this case.
         return UNKNOWN;
     }
   }
 
-  // The user didn't type a scheme.  Assume that this is either an HTTP URL or
-  // not a URL at all; try to determine which.
+  // Either the user didn't type a scheme, in which case we need to distinguish
+  // between an HTTP URL and a query, or the scheme is HTTP or HTTPS, in which
+  // case we should reject invalid formulations.
 
-  // It's not clear that we can reach here with an empty "host" (maybe on some
-  // kinds of garbage input?), but if we did, it couldn't be a URL.
+  // If we have an empty host it can't be a URL.
   if (!parts->host.is_nonempty())
     return QUERY;
-  // (We use the registry length later below but ask for it here so we can check
-  // the host's validity at this point.)
+
+  // Likewise, the RCDS can reject certain obviously-invalid hosts.  (We also
+  // use the registry length later below.)
   const std::wstring host(text.substr(parts->host.begin, parts->host.len));
   const size_t registry_length =
       net::RegistryControlledDomainService::GetRegistryLength(host, false);
   if (registry_length == std::wstring::npos)
     return QUERY;  // Could be a broken IP address, etc.
 
   // See if the hostname is valid per RFC 1738.  While IE and GURL allow
   // hostnames to contain many other characters (perhaps for weird intranet
   // machines), it's extremely unlikely that a user would be trying to type
   // those in for anything other than a search query.
   url_canon::CanonHostInfo host_info;
   const std::string canonicalized_host(net::CanonicalizeHost(host, &host_info));
   if ((host_info.family == url_canon::CanonHostInfo::NEUTRAL) &&
       !net::IsCanonicalizedHostRFC1738Compliant(canonicalized_host))
     return QUERY;
 
   // Presence of a port means this is likely a URL, if the port is really a port
   // number.  If it's just garbage after a colon, this is a query.
   if (parts->port.is_nonempty()) {
     int port;
     return (StringToInt(WideToUTF16(
                 text.substr(parts->port.begin, parts->port.len)), &port) &&
             (port >= 0) && (port <= 65535)) ? URL : QUERY;
   }
 
-  // Presence of a password means this is likely a URL.  We don't treat
-  // usernames (without passwords) as indicating a URL, because this could be an
-  // email address like "user@mail.com" which is more likely a search than an
-  // HTTP auth login attempt.
+  // Presence of a username could either indicate a URL or an email address
+  // ("user@mail.com").  E-mail addresses are likely queries so we only open
+  // this as a URL if the user explicitly typed a scheme.
+  if (parts->username.is_nonempty() && parts->scheme.is_nonempty())
+    return URL;
+
+  // Presence of a password means this is likely a URL.  Note that unless the
+  // user has typed an explicit "http://" or similar, we'll probably think that
+  // the username is some unknown scheme, and bail out in the scheme-handling
+  // code above.
   if (parts->password.is_nonempty())
     return URL;
 
   // See if the host is an IP address.
   if (host_info.family == url_canon::CanonHostInfo::IPV4) {
     // If the user originally typed a host that looks like an IP address (a
     // dotted quad), they probably want to open it.  If the original input was
     // something else (like a single number), they probably wanted to search for
-    // it.  This is true even if the URL appears to have a path: "1.2/45" is
-    // more likely a search (for the answer to a math problem) than a URL.
-    if (host_info.num_ipv4_components == 4)
+    // it, unless they explicitly typed a scheme.  This is true even if the URL
+    // appears to have a path: "1.2/45" is more likely a search (for the answer
+    // to a math problem) than a URL.
+    if ((host_info.num_ipv4_components == 4) || parts->scheme.is_nonempty())
       return URL;
     return desired_tld.empty() ? UNKNOWN : REQUESTED_URL;
   }
   if (host_info.family == url_canon::CanonHostInfo::IPV6)
     return URL;
 
   // The host doesn't look like a number, so see if the user's given us a path.
   if (parts->path.is_nonempty()) {
     // Most inputs with paths are URLs, even ones without known registries (e.g.
-    // intranet URLs).  However, if there's no known registry, and the path has
-    // a space, this is more likely a query with a slash in the first term (e.g.
-    // "ps/2 games") than a URL.  We can still open URLs with spaces in the path
-    // by escaping the space, and we will still inline autocomplete them if
-    // users have typed them in the past, but we default to searching since
-    // that's the common case.
-    return ((registry_length == 0) &&
+    // intranet URLs).  However, if the user didn't type a scheme, there's no
+    // known registry, and the path has a space, this is more likely a query
+    // with a slash in the first term (e.g. "ps/2 games") than a URL.  We can
+    // still open URLs with spaces in the path by escaping the space, and we
+    // will still inline autocomplete them if users have typed them in the past,
+    // but we default to searching since that's the common case.
+    return (!parts->scheme.is_nonempty() && (registry_length == 0) &&
             (text.substr(parts->path.begin, parts->path.len).find(' ') !=
                 std::wstring::npos)) ? UNKNOWN : URL;
   }
 
   // If we reach here with a username, our input looks like "user@host"; this is
   // the case mentioned above, where we think this is more likely an email
   // address than an HTTP auth attempt, so search for it.
   if (parts->username.is_nonempty())
     return UNKNOWN;
 
-  // We have a bare host string.  See if it has a known TLD.  If so, it's
-  // probably a URL.
-  if (registry_length != 0)
+  // We have a bare host string.  See if it has a known TLD or the user typed a
+  // scheme.  If so, it's probably a URL.
+  if (parts->scheme.is_nonempty() || (registry_length != 0))
     return URL;
 
   // No TLD that we know about.  This could be:
   // * A string that the user wishes to add a desired_tld to to get a URL.  If
   //   we reach this point, we know there's no known TLD on the string, so the
   //   fixup code will be willing to add one; thus this is a URL.
   // * A single word "foo"; possibly an intranet site, but more likely a search.
   //   This is ideally an UNKNOWN, and we can let the Alternate Nav URL code
   //   catch our mistakes.
   // * A URL with a valid TLD we don't know about yet.  If e.g. a registrar adds
@@ skipping 683 matching lines @@
 void AutocompleteController::CheckIfDone() {
   for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     if (!(*i)->done()) {
       done_ = false;
       return;
     }
   }
   done_ = true;
 }