Omnibox: Combine Two Input Type Enums into One

chrome/browser/autocomplete/history_url_provider.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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/history/scored_history_match.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/url_fixer_upper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
+#include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/gurl.h"
 #include "url/url_parse.h"
 #include "url/url_util.h"
 
 namespace {
 
 // If |create_if_necessary| is true, ensures that |matches| contains an
 // entry for |info|, creating a new such entry if necessary (using
@@ skipping 282 matching lines @@
     const AutocompleteInput& input,
     history::URLDatabase* db)
     : provider_(provider),
       db_(db),
       type_(INVALID) {
   const GURL& url = input.canonicalized_url();
   // Detect email addresses.  These cases will look like "http://user@site/",
   // and because the history backend strips auth creds, we'll get a bogus exact
   // match below if the user has visited "site".
   if (!url.is_valid() ||
-      ((input.type() == AutocompleteInput::UNKNOWN) &&
+      ((input.type() == metrics::OmniboxInputType::UNKNOWN) &&
        input.parts().username.is_nonempty() &&
        !input.parts().password.is_nonempty() &&
        !input.parts().path.is_nonempty()))
     return;
 
   if (db_->GetRowForURL(url, &url_row_)) {
     type_ = VISITED;
     return;
   }
 
@@ skipping 155 matching lines @@
   //
   // We display this to the user when there's a reasonable chance they actually
   // care:
   // * Their input can be opened as a URL, and
   // * We parsed the input as a URL, or it starts with an explicit "http:" or
   //   "https:".
   //  that is when their input can be opened as a URL.
   // Otherwise, this is just low-quality noise.  In the cases where we've parsed
   // as UNKNOWN, we'll still show an accidental search infobar if need be.
   bool have_what_you_typed_match =
-      (params->input.type() != AutocompleteInput::QUERY) &&
-      ((params->input.type() != AutocompleteInput::UNKNOWN) ||
+      (params->input.type() != metrics::OmniboxInputType::QUERY) &&
+      ((params->input.type() != metrics::OmniboxInputType::UNKNOWN) ||
        (classifier.type() == VisitClassifier::UNVISITED_INTRANET) ||
        !params->trim_http ||
        (AutocompleteInput::NumNonHostComponents(params->input.parts()) > 0));
   AutocompleteMatch what_you_typed_match(SuggestExactInput(
       params->input.text(), params->input.canonicalized_url(),
       params->trim_http));
   what_you_typed_match.relevance = CalculateRelevance(WHAT_YOU_TYPED, 0);
 
   // Get the matching URLs from the DB
   history::URLRows url_matches;
@@ skipping 159 matching lines @@
       return kBaseScoreForNonInlineableResult +
           static_cast<int>(match_number);
   }
 }
 
 void HistoryURLProvider::RunAutocompletePasses(
     const AutocompleteInput& input,
     bool fixup_input_and_run_pass_1) {
   matches_.clear();
 
-  if ((input.type() == AutocompleteInput::INVALID) ||
-      (input.type() == AutocompleteInput::FORCED_QUERY))
+  if ((input.type() == metrics::OmniboxInputType::INVALID) ||
+      (input.type() == metrics::OmniboxInputType::FORCED_QUERY))
     return;
 
   // Create a match for exactly what the user typed.  This will only be used as
   // a fallback in case we can't get the history service or URL DB; otherwise,
   // we'll run this again in DoAutocomplete() and use that result instead.
   const bool trim_http = !AutocompleteInput::HasHTTPScheme(input.text());
   // Don't do this for queries -- while we can sometimes mark up a match for
   // this, it's not what the user wants, and just adds noise.
-  if (input.type() != AutocompleteInput::QUERY) {
+  if (input.type() != metrics::OmniboxInputType::QUERY) {
     AutocompleteMatch what_you_typed(SuggestExactInput(
         input.text(), input.canonicalized_url(), trim_http));
     what_you_typed.relevance = CalculateRelevance(WHAT_YOU_TYPED, 0);
     matches_.push_back(what_you_typed);
   }
 
   // We'll need the history service to run both passes, so try to obtain it.
   if (!profile_)
     return;
   HistoryService* const history_service =
@@ skipping 106 matching lines @@
   // make sure that this code does not trigger if the user did anything to
   // indicate the desired match is a URL.  For instance, "c/# foo" will not
   // pass the test because that will be classified as input type URL.  The
   // parsed.CountCharactersBefore() in the test looks for the presence of a
   // reference fragment in the URL by checking whether the position differs
   // included the delimiter (pound sign) versus not including the delimiter.
   // (One cannot simply check url.ref() because it will not distinguish
   // between the input "c" and the input "c#", both of which will have empty
   // reference fragments.)
   if ((type == UNVISITED_INTRANET) &&
-      (input.type() != AutocompleteInput::URL) && url.username().empty() &&
-      url.password().empty() && url.port().empty() && (url.path() == "/") &&
-      url.query().empty() &&
+      (input.type() != metrics::OmniboxInputType::URL) &&
+      url.username().empty() && url.password().empty() && url.port().empty() &&
+      (url.path() == "/") && url.query().empty() &&
       (parsed.CountCharactersBefore(url::Parsed::REF, true) !=
        parsed.CountCharactersBefore(url::Parsed::REF, false))) {
     return false;
   }
 
   match->relevance = CalculateRelevance(type, 0);
 
   // If there are any other matches, then don't promote this match here, in
   // hopes the caller will be able to inline autocomplete a better suggestion.
   // DoAutocomplete() will fall back on this match if inline autocompletion
   // fails.  This matches how we react to never-visited URL inputs in the non-
   // intranet case.
   if (type == UNVISITED_INTRANET && !matches->empty())
     return false;
 
   // Put it on the front of the HistoryMatches for redirect culling.
   CreateOrPromoteMatch(classifier.url_row(), base::string16::npos, false,
                        matches, true, true);
   return true;
 }
 
 bool HistoryURLProvider::CanFindIntranetURL(
     history::URLDatabase* db,
     const AutocompleteInput& input) const {
   // Normally passing the first two conditions below ought to guarantee the
   // third condition, but because FixupUserInput() can run and modify the
   // input's text and parts between Parse() and here, it seems better to be
   // paranoid and check.
-  if ((input.type() != AutocompleteInput::UNKNOWN) ||
+  if ((input.type() != metrics::OmniboxInputType::UNKNOWN) ||
       !LowerCaseEqualsASCII(input.scheme(), url::kHttpScheme) ||
       !input.parts().host.is_nonempty())
     return false;
   const std::string host(base::UTF16ToUTF8(
       input.text().substr(input.parts().host.begin, input.parts().host.len)));
   const size_t registry_length =
       net::registry_controlled_domains::GetRegistryLength(
           host,
           net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
@@ skipping 283 matching lines @@
   // If HistoryURL retrieves any matches (and hence we reach this code), we
   // are guaranteed that the beginning of input_text must be a word break.
   history::WordStarts offsets(1, 0u);
   description_matches =
       history::ScoredHistoryMatch::FilterTermMatchesByWordStarts(
           description_matches, offsets, description_word_starts, 0,
           std::string::npos);
   return SpansFromTermMatch(
       description_matches, clean_description.length(), false);
 }