Omnibox: Combine Two Input Type Enums into One

chrome/browser/autocomplete/autocomplete_input.cc

 // Copyright (c) 2012 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_input.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/profiles/profile_io_data.h"
@@ skipping 14 matching lines @@
     *cursor_position -= num_leading_chars_removed;
   else
     *cursor_position = 0;
 }
 
 }  // namespace
 
 AutocompleteInput::AutocompleteInput()
     : cursor_position_(base::string16::npos),
       current_page_classification_(AutocompleteInput::INVALID_SPEC),
-      type_(INVALID),
+      type_(metrics::OmniboxInputType::INVALID),
       prevent_inline_autocomplete_(false),
       prefer_keyword_(false),
       allow_exact_keyword_match_(true),
       want_asynchronous_matches_(true) {
 }
 
 AutocompleteInput::AutocompleteInput(
     const base::string16& text,
     size_t cursor_position,
     const base::string16& desired_tld,
@@ skipping 16 matching lines @@
   // None of the providers care about leading white space so we always trim it.
   // Providers that care about trailing white space handle trimming themselves.
   if ((base::TrimWhitespace(text, base::TRIM_LEADING, &text_) &
        base::TRIM_LEADING) != 0)
     AdjustCursorPositionIfNecessary(text.length() - text_.length(),
                                     &cursor_position_);
 
   GURL canonicalized_url;
   type_ = Parse(text_, desired_tld, &parts_, &scheme_, &canonicalized_url);
 
-  if (type_ == INVALID)
+  if (type_ == metrics::OmniboxInputType::INVALID)
     return;
 
-  if (((type_ == UNKNOWN) || (type_ == URL)) &&
+  if (((type_ == metrics::OmniboxInputType::UNKNOWN) ||
+       (type_ == metrics::OmniboxInputType::URL)) &&
       canonicalized_url.is_valid() &&
       (!canonicalized_url.IsStandard() || canonicalized_url.SchemeIsFile() ||
        canonicalized_url.SchemeIsFileSystem() ||
        !canonicalized_url.host().empty()))
     canonicalized_url_ = canonicalized_url;
 
   size_t chars_removed = RemoveForcedQueryStringIfNecessary(type_, &text_);
   AdjustCursorPositionIfNecessary(chars_removed, &cursor_position_);
   if (chars_removed) {
     // Remove spaces between opening question mark and first actual character.
     base::string16 trimmed_text;
     if ((base::TrimWhitespace(text_, base::TRIM_LEADING, &trimmed_text) &
          base::TRIM_LEADING) != 0) {
       AdjustCursorPositionIfNecessary(text_.length() - trimmed_text.length(),
                                       &cursor_position_);
       text_ = trimmed_text;
     }
   }
 }
 
 AutocompleteInput::~AutocompleteInput() {
 }
 
 // static
 size_t AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-    Type type,
+    metrics::OmniboxInputType::Type type,
     base::string16* text) {
-  if (type != FORCED_QUERY || text->empty() || (*text)[0] != L'?')
+  if ((type != metrics::OmniboxInputType::FORCED_QUERY) || text->empty() ||
+      (*text)[0] != L'?')
     return 0;
   // Drop the leading '?'.
   text->erase(0, 1);
   return 1;
 }
 
 // static
-std::string AutocompleteInput::TypeToString(Type type) {
+std::string AutocompleteInput::TypeToString(
+    metrics::OmniboxInputType::Type type) {
   switch (type) {
-    case INVALID:       return "invalid";
-    case UNKNOWN:       return "unknown";
-    case URL:           return "url";
-    case QUERY:         return "query";
-    case FORCED_QUERY:  return "forced-query";
+    case metrics::OmniboxInputType::INVALID:       return "invalid";
+    case metrics::OmniboxInputType::UNKNOWN:       return "unknown";
+    case metrics::OmniboxInputType::URL:           return "url";
+    case metrics::OmniboxInputType::QUERY:         return "query";
+    case metrics::OmniboxInputType::FORCED_QUERY:  return "forced-query";
 
     default:
       NOTREACHED();
       return std::string();

[Ilya Sherman, 2014/06/06 05:01:01]

I'd prefer that you remove the default case, so that the compiler can remind you
if this ever needs to be updated.

[Mark P, 2014/06/06 20:22:51]

Done.  Like in the other place, note that I add to add DEPRECATED_REQUESTED_URL
and INVALID to the case list here.  Without the default block, I also needed to
add a return at the end of the function (outside the switch).  With these
changes, I'm not sure this is an improvement.  What do you think?

[Ilya Sherman, 2014/06/06 20:29:24]

Yes, I think it's still an improvement.  The code is slightly longer, but not in
a way that much harms readability; and you get the benefit that the compiler
will help you avoid bugs in the future.  IMO that's a great tradeoff.

   }
 }
 
 // static
-AutocompleteInput::Type AutocompleteInput::Parse(
+metrics::OmniboxInputType::Type AutocompleteInput::Parse(
     const base::string16& text,
     const base::string16& desired_tld,
     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 INVALID;  // All whitespace.
+    return metrics::OmniboxInputType::INVALID;  // All whitespace.
 
   if (text[first_non_white] == L'?') {
     // If the first non-whitespace character is a '?', we magically treat this
     // as a query.
-    return FORCED_QUERY;
+    return metrics::OmniboxInputType::FORCED_QUERY;
   }
 
   // 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(URLFixerUpper::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
 
   // If we can't canonicalize the user's input, the rest of the autocomplete
   // system isn't going to be able to produce a navigable URL match for it.
   // So we just return QUERY immediately in these cases.
   GURL placeholder_canonicalized_url;
   if (!canonicalized_url)
     canonicalized_url = &placeholder_canonicalized_url;
   *canonicalized_url = URLFixerUpper::FixupURL(base::UTF16ToUTF8(text),
                                                base::UTF16ToUTF8(desired_tld));
   if (!canonicalized_url->is_valid())
-    return QUERY;
+    return metrics::OmniboxInputType::QUERY;
 
   if (LowerCaseEqualsASCII(parsed_scheme, url::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme| will tell us that this is a file URL, but
     // |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
-    return URL;
+    return metrics::OmniboxInputType::URL;
   }
 
   // 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() &&
       !LowerCaseEqualsASCII(parsed_scheme, url::kHttpScheme) &&
       !LowerCaseEqualsASCII(parsed_scheme, url::kHttpsScheme)) {
     // See if we know how to handle the URL internally.  There are some schemes
     // that we convert to other things before they reach the renderer or else
     // the renderer handles internally without reaching the net::URLRequest
     // logic.  They thus won't be listed as "handled protocols", but we should
     // still claim to handle them.
     if (ProfileIOData::IsHandledProtocol(base::UTF16ToASCII(parsed_scheme)) ||
         LowerCaseEqualsASCII(parsed_scheme, content::kViewSourceScheme) ||
         LowerCaseEqualsASCII(parsed_scheme, url::kJavaScriptScheme) ||
         LowerCaseEqualsASCII(parsed_scheme, url::kDataScheme))
-      return URL;
+      return metrics::OmniboxInputType::URL;
 
     // Not an internal protocol.  Check and see if the user has explicitly
     // opened this scheme as a URL before, or if the "scheme" is actually a
     // username.  We need to do this after the check above because some
     // handlable schemes (e.g. "javascript") may be treated as "blocked" by the
     // external protocol handler because we don't want pages to open them, but
     // users still can.
     // Note that the protocol handler needs to be informed that omnibox input
     // should always be considered "user gesture-triggered", lest it always
     // return BLOCK.
     ExternalProtocolHandler::BlockState block_state =
         ExternalProtocolHandler::GetBlockState(
             base::UTF16ToUTF8(parsed_scheme), true);
     switch (block_state) {
       case ExternalProtocolHandler::DONT_BLOCK:
-        return URL;
+        return metrics::OmniboxInputType::URL;
 
       case ExternalProtocolHandler::BLOCK:
         // If we don't want the user to open the URL, don't let it be navigated
         // to at all.
-        return QUERY;
+        return metrics::OmniboxInputType::QUERY;
 
       default: {
         // We don't know about this scheme.  It might be that the user typed a
         // URL of the form "username:password@foo.com".
         const base::string16 http_scheme_prefix =
             base::ASCIIToUTF16(std::string(url::kHttpScheme) +
                                content::kStandardSchemeSeparator);
         url::Parsed http_parts;
         base::string16 http_scheme;
         GURL http_canonicalized_url;
-        Type http_type = Parse(http_scheme_prefix + text, desired_tld,
-                               &http_parts, &http_scheme,
-                               &http_canonicalized_url);
+        metrics::OmniboxInputType::Type http_type =
+            Parse(http_scheme_prefix + text, desired_tld, &http_parts,
+                  &http_scheme, &http_canonicalized_url);
         DCHECK_EQ(std::string(url::kHttpScheme),
                   base::UTF16ToUTF8(http_scheme));
 
-        if ((http_type == URL) && http_parts.username.is_nonempty() &&
+        if ((http_type == metrics::OmniboxInputType::URL) &&
+            http_parts.username.is_nonempty() &&
             http_parts.password.is_nonempty()) {
           // Manually re-jigger the parsed parts to match |text| (without the
           // http scheme added).
           http_parts.scheme.reset();
           url::Component* components[] = {
             &http_parts.username,
             &http_parts.password,
             &http_parts.host,
             &http_parts.port,
             &http_parts.path,
             &http_parts.query,
             &http_parts.ref,
           };
           for (size_t i = 0; i < arraysize(components); ++i) {
             URLFixerUpper::OffsetComponent(
                 -static_cast<int>(http_scheme_prefix.length()), components[i]);
           }
 
           *parts = http_parts;
           if (scheme)
             scheme->clear();
           *canonicalized_url = http_canonicalized_url;
 
-          return URL;
+          return metrics::OmniboxInputType::URL;
         }
 
         // We don't know about this scheme and it doesn't look like the user
         // typed a username and password.  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;
+        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 (!parts->host.is_nonempty())
-    return QUERY;
+    return metrics::OmniboxInputType::QUERY;
 
   // Sanity-check: GURL should have failed to canonicalize this URL if it had an
   // invalid port.
   DCHECK_NE(url::PORT_INVALID, url::ParsePort(text.c_str(), parts->port));
 
   // Likewise, the RCDS can reject certain obviously-invalid hosts.  (We also
   // use the registry length later below.)
   const base::string16 host(text.substr(parts->host.begin, parts->host.len));
   const size_t registry_length =
       net::registry_controlled_domains::GetRegistryLength(
           base::UTF16ToUTF8(host),
           net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   if (registry_length == std::string::npos) {
     // Try to append the desired_tld.
     if (!desired_tld.empty()) {
       base::string16 host_with_tld(host);
       if (host[host.length() - 1] != '.')
         host_with_tld += '.';
       host_with_tld += desired_tld;
       const size_t tld_length =
           net::registry_controlled_domains::GetRegistryLength(
               base::UTF16ToUTF8(host_with_tld),
               net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
               net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
-      if (tld_length != std::string::npos)
-        return URL;  // Something like "99999999999" that looks like a bad IP
-                     // address, but becomes valid on attaching a TLD.
+      if (tld_length != std::string::npos) {
+        // Something like "99999999999" that looks like a bad IP
+        // address, but becomes valid on attaching a TLD.
+        return metrics::OmniboxInputType::URL;
+      }
     }
-    return QUERY;  // Could be a broken IP address, etc.
+    // Could be a broken IP address, etc.
+    return metrics::OmniboxInputType::QUERY;
   }
 
 
   // See if the hostname is valid.  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::CanonHostInfo host_info;
   const std::string canonicalized_host(net::CanonicalizeHost(
       base::UTF16ToUTF8(host), &host_info));
@@ skipping 13 matching lines @@
     //   "toys at amazon.com" will be treated as a search.
     // * The user is typing some garbage string.  Return QUERY.
     //
     // Thus we fall down in the following cases:
     // * Trying to navigate to a hostname with spaces
     // * Trying to navigate to a hostname with invalid characters and an unknown
     //   TLD
     // These are rare, though probably possible in intranets.
     return (parts->scheme.is_nonempty() ||
            ((registry_length != 0) &&
-            (host.find(' ') == base::string16::npos))) ? UNKNOWN : QUERY;
+            (host.find(' ') == base::string16::npos))) ?
+        metrics::OmniboxInputType::UNKNOWN : metrics::OmniboxInputType::QUERY;
   }
 
   // Now that we've ruled out all schemes other than http or https and done a
   // little more sanity checking, the presence of a scheme means this is likely
   // a URL.
   if (parts->scheme.is_nonempty())
-    return URL;
+    return metrics::OmniboxInputType::URL;
 
   // See if the host is an IP address.
   if (host_info.family == url::CanonHostInfo::IPV6)
-    return URL;
+    return metrics::OmniboxInputType::URL;
   // 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, 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.  However, if there are more non-host
   // components, then maybe this really was intended to be a navigation.  For
   // this reason we only check the dotted-quad case here, and save the "other
   // IP addresses" case for after we check the number of non-host components
   // below.
   if ((host_info.family == url::CanonHostInfo::IPV4) &&
       (host_info.num_ipv4_components == 4))
-    return URL;
+    return metrics::OmniboxInputType::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;
+    return metrics::OmniboxInputType::URL;
 
   // Trailing slashes force the input to be treated as a URL.
   if (parts->path.is_nonempty()) {
     char c = text[parts->path.end() - 1];
     if ((c == '\\') || (c == '/'))
-      return URL;
+      return metrics::OmniboxInputType::URL;
   }
 
   // If there is more than one recognized non-host component, this is likely to
   // be a URL, even if the TLD is unknown (in which case this is likely an
   // intranet URL).
   if (NumNonHostComponents(*parts) > 1)
-    return URL;
+    return metrics::OmniboxInputType::URL;
 
   // If the host has a known TLD or a port, it's probably a URL, with the
   // following exceptions:
   // * Any "IP addresses" that make it here are more likely searches
   //   (see above).
   // * If we reach here with a username, our input looks like "user@host[.tld]".
   //   Because there is no scheme explicitly specified, we think this is more
   //   likely an email address than an HTTP auth attempt.  Hence, we search by
   //   default and let users correct us on a case-by-case basis.
   // Note that we special-case "localhost" as a known hostname.
   if ((host_info.family != url::CanonHostInfo::IPV4) &&
       ((registry_length != 0) || (host == base::ASCIIToUTF16("localhost") ||
        parts->port.is_nonempty())))
-    return parts->username.is_nonempty() ? UNKNOWN : URL;
+    return parts->username.is_nonempty() ?
+        metrics::OmniboxInputType::UNKNOWN : metrics::OmniboxInputType::URL;
 
   // If we reach this point, we know there's no known TLD on the input, so if
   // the user wishes to add a desired_tld, the fixup code will oblige; thus this
   // is a URL.
   if (!desired_tld.empty())
-    return URL;
+    return metrics::OmniboxInputType::URL;
 
   // No scheme, password, port, path, and no known TLD on the host.
   // This could be:
   // * An "incomplete IP address"; likely a search (see above).
   // * An email-like input like "user@host", where "host" has no known TLD.
   //   It's not clear what the user means here and searching seems reasonable.
   // * 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
   //   "xxx" as a TLD, then until we add it to our data file, Chrome won't know
   //   "foo.xxx" is a real URL.  So ideally this is a URL, but we can't really
   //   distinguish this case from:
   // * A "URL-like" string that's not really a URL (like
   //   "browser.tabs.closeButtons" or "java.awt.event.*").  This is ideally a
   //   QUERY.  Since this is indistinguishable from the case above, and this
   //   case is much more likely, claim these are UNKNOWN, which should default
   //   to the right thing and let users correct us on a case-by-case basis.
-  return UNKNOWN;
+  return metrics::OmniboxInputType::UNKNOWN;
 }
 
 // static
 void AutocompleteInput::ParseForEmphasizeComponents(const base::string16& text,
                                                     url::Component* scheme,
                                                     url::Component* host) {
   url::Parsed parts;
   base::string16 scheme_str;
   Parse(text, base::string16(), &parts, &scheme_str, NULL);
 
@@ skipping 84 matching lines @@
   text_ = text;
   cursor_position_ = cursor_position;
   parts_ = parts;
 }
 
 void AutocompleteInput::Clear() {
   text_.clear();
   cursor_position_ = base::string16::npos;
   current_url_ = GURL();
   current_page_classification_ = AutocompleteInput::INVALID_SPEC;
-  type_ = INVALID;
+  type_ = metrics::OmniboxInputType::INVALID;
   parts_ = url::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   want_asynchronous_matches_ = true;
 }