Mark URLs with empty schemes as invalid.

components/omnibox/browser/autocomplete_input.cc

 // Copyright 2014 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 "components/omnibox/browser/autocomplete_input.h"
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 137 matching lines @@
     const base::string16& text,
     const std::string& desired_tld,
     const AutocompleteSchemeClassifier& scheme_classifier,
     url::Parsed* parts,
     base::string16* scheme,
     GURL* canonicalized_url) {
   size_t first_non_white = text.find_first_not_of(base::kWhitespaceUTF16, 0);
   if (first_non_white == base::string16::npos)
     return metrics::OmniboxInputType::INVALID;  // All whitespace.
 
+  // Treat input that beings with a colon as a query. Otherwise the URL

[Peter Kasting, 2016/09/29 04:54:12]

Nit: begins

+  // formatter will attempt to fix it by prepending a scheme, which the user
+  // probably did not want if they explicitly typed a colon at the beginning.
+  if (text[first_non_white] == ':')
+    return metrics::OmniboxInputType::QUERY;

[Peter Kasting, 2016/09/29 04:54:12]

It would be nice to avoid doing this check here, and maybe instead detect this
lower down, ideally without actually looking for an explicit colon.

Where does control flow go if we don't do this here?  You implied ":w" will
become a navigation, but I don't know what exit point below we actually take in
that case.  (Especially depending on whether you make other changes to stuff I
comment on elsewhere.)

+
   // Ask our parsing back-end to help us understand what the user typed.  We
   // use the URLFixerUpper here because we want to be smart about what we
   // consider a scheme.  For example, we shouldn't consider www.google.com:80
   // to have a scheme.
   url::Parsed local_parts;
   if (!parts)
     parts = &local_parts;
   const base::string16 parsed_scheme(url_formatter::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
@@ skipping 79 matching lines @@
     // 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 metrics::OmniboxInputType::UNKNOWN;
   }
 
   // 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.
 
-  // If we have an empty host it can't be a valid HTTP[S] URL.  (This should
-  // only trigger for input that begins with a colon, which GURL will parse as a
-  // valid, non-standard URL; for standard URLs, an empty host would have
-  // resulted in an invalid |canonicalized_url| above.)
-  if (!canonicalized_url->has_host())
-    return metrics::OmniboxInputType::QUERY;
-
   // Determine the host family.  We get this information by (re-)canonicalizing
   // the already-canonicalized host rather than using the user's original input,
   // in case fixup affected the result here (e.g. an input that looks like an
   // IPv4 address but with a non-empty desired TLD would return IPV4 before
   // fixup and NEUTRAL afterwards, and we want to treat it as NEUTRAL).
   url::CanonHostInfo host_info;
   net::CanonicalizeHost(canonicalized_url->host(), &host_info);
 
   // Check if the canonicalized host has a known TLD, which we'll want to know
   // below.
@@ skipping 252 matching lines @@
   parts_ = url::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   want_asynchronous_matches_ = true;
   from_omnibox_focus_ = false;
   terms_prefixed_by_http_or_https_.clear();
 }