Revert of Omnibox: Combine Two Input Type Enums into One

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base64.h"
@@ skipping 21 matching lines @@
 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/search/instant_controller.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
-#include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/url_constants.h"
@@ skipping 117 matching lines @@
   // scores verbatim query matches for extension keywords, as well as
   // for keyword matches (i.e., suggestions of a keyword itself, not a
   // suggestion of a query on a keyword search engine).  These two
   // functions are currently in sync, but there's no reason we
   // couldn't decide in the future to score verbatim matches
   // differently for extension and non-extension keywords.  If you
   // make such a change, however, you should update this comment to
   // describe it, so it's clear why the functions diverge.
   if (prefer_keyword)
     return 1500;
-  return (type == metrics::OmniboxInputType::QUERY) ? 1450 : 1100;
+  return (type == AutocompleteInput::QUERY) ? 1450 : 1100;
 }
 
 void SearchProvider::Start(const AutocompleteInput& input,
                            bool minimal_changes) {
   // Do our best to load the model as early as possible.  This will reduce
   // odds of having the model not ready when really needed (a non-empty input).
   TemplateURLService* model = providers_.template_url_service();
   DCHECK(model);
   model->Load();
 
   matches_.clear();
   field_trial_triggered_ = false;
 
   // Can't return search/suggest results for bogus input or without a profile.
-  if (!profile_ || (input.type() == metrics::OmniboxInputType::INVALID)) {
+  if (!profile_ || (input.type() == AutocompleteInput::INVALID)) {
     Stop(true);
     return;
   }
 
   keyword_input_ = input;
   const TemplateURL* keyword_provider =
       KeywordProvider::GetSubstitutingTemplateURLForInput(model,
                                                           &keyword_input_);
   if (keyword_provider == NULL)
     keyword_input_.Clear();
@@ skipping 337 matching lines @@
       ((!default_url || default_url->suggestions_url().empty()) &&
        (!keyword_url || keyword_url->suggestions_url().empty())) ||
       !profile_->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled))
     return false;
 
   // If the input type might be a URL, we take extra care so that private data
   // isn't sent to the server.
 
   // FORCED_QUERY means the user is explicitly asking us to search for this, so
   // we assume it isn't a URL and/or there isn't private data.
-  if (input_.type() == metrics::OmniboxInputType::FORCED_QUERY)
+  if (input_.type() == AutocompleteInput::FORCED_QUERY)
     return true;
 
   // Next we check the scheme.  If this is UNKNOWN/URL with a scheme that isn't
   // http/https/ftp, we shouldn't send it.  Sending things like file: and data:
   // is both a waste of time and a disclosure of potentially private, local
   // data.  Other "schemes" may actually be usernames, and we don't want to send
   // passwords.  If the scheme is OK, we still need to check other cases below.
   // If this is QUERY, then the presence of these schemes means the user
   // explicitly typed one, and thus this is probably a URL that's being entered
   // and happens to currently be invalid -- in which case we again want to run
   // our checks below.  Other QUERY cases are less likely to be URLs and thus we
   // assume we're OK.
   if (!LowerCaseEqualsASCII(input_.scheme(), url::kHttpScheme) &&
       !LowerCaseEqualsASCII(input_.scheme(), url::kHttpsScheme) &&
       !LowerCaseEqualsASCII(input_.scheme(), url::kFtpScheme))
-    return (input_.type() == metrics::OmniboxInputType::QUERY);
+    return (input_.type() == AutocompleteInput::QUERY);
 
   // Don't send URLs with usernames, queries or refs.  Some of these are
   // private, and the Suggest server is unlikely to have any useful results
   // for any of them.  Also don't send URLs with ports, as we may initially
   // think that a username + password is a host + port (and we don't want to
   // send usernames/passwords), and even if the port really is a port, the
   // server is once again unlikely to have and useful results.
   // Note that we only block based on refs if the input is URL-typed, as search
   // queries can legitimately have #s in them which the URL parser
   // overaggressively categorizes as a url with a ref.
   const url::Parsed& parts = input_.parts();
   if (parts.username.is_nonempty() || parts.port.is_nonempty() ||
       parts.query.is_nonempty() ||
-      (parts.ref.is_nonempty() &&
-       (input_.type() == metrics::OmniboxInputType::URL)))
+      (parts.ref.is_nonempty() && (input_.type() == AutocompleteInput::URL)))
     return false;
 
   // Don't send anything for https except the hostname.  Hostnames are OK
   // because they are visible when the TCP connection is established, but the
   // specific path may reveal private information.
   if (LowerCaseEqualsASCII(input_.scheme(), url::kHttpsScheme) &&
       parts.path.is_nonempty())
     return false;
 
   return true;
@@ skipping 212 matching lines @@
        ++it) {
     if ((it->keyword == keyword_url->keyword()) &&
         it->allowed_to_be_default_match)
       return true;
   }
   return false;
 }
 
 bool SearchProvider::IsTopMatchSearchWithURLInput() const {
   ACMatches::const_iterator first_match = FindTopMatch();
-  return (input_.type() == metrics::OmniboxInputType::URL) &&
+  return (input_.type() == AutocompleteInput::URL) &&
       (first_match != matches_.end()) &&
       (first_match->relevance > CalculateRelevanceForVerbatim()) &&
       (first_match->type != AutocompleteMatchType::NAVSUGGEST) &&
       (first_match->type != AutocompleteMatchType::NAVSUGGEST_PERSONALIZED);
 }
 
 void SearchProvider::AddNavigationResultsToMatches(
     const NavigationResults& navigation_results,
     ACMatches* matches) {
   for (NavigationResults::const_iterator it = navigation_results.begin();
         it != navigation_results.end(); ++it) {
     matches->push_back(NavigationToMatch(*it));
     // In the absence of suggested relevance scores, use only the single
     // highest-scoring result.  (The results are already sorted by relevance.)
     if (!it->relevance_from_server())
       return;
   }
 }
 
 void SearchProvider::AddHistoryResultsToMap(const HistoryResults& results,
                                             bool is_keyword,
                                             int did_not_accept_suggestion,
                                             MatchMap* map) {
   if (results.empty())
     return;
 
   base::TimeTicks start_time(base::TimeTicks::Now());
   bool prevent_inline_autocomplete = input_.prevent_inline_autocomplete() ||
-      (input_.type() == metrics::OmniboxInputType::URL);
+      (input_.type() == AutocompleteInput::URL);
   const base::string16& input_text =
       is_keyword ? keyword_input_.text() : input_.text();
   bool input_multiple_words = HasMultipleWords(input_text);
 
   SuggestResults scored_results;
   if (!prevent_inline_autocomplete && input_multiple_words) {
     // ScoreHistoryResults() allows autocompletion of multi-word, 1-visit
     // queries if the input also has multiple words.  But if we were already
     // scoring a multi-word, multi-visit query aggressively, and the current
     // input is still a prefix of it, then changing the suggestion suddenly
@@ skipping 125 matching lines @@
 
 int SearchProvider::CalculateRelevanceForVerbatim() const {
   if (!providers_.keyword_provider().empty())
     return 250;
   return CalculateRelevanceForVerbatimIgnoringKeywordModeState();
 }
 
 int SearchProvider::
     CalculateRelevanceForVerbatimIgnoringKeywordModeState() const {
   switch (input_.type()) {
-    case metrics::OmniboxInputType::UNKNOWN:
-    case metrics::OmniboxInputType::QUERY:
-    case metrics::OmniboxInputType::FORCED_QUERY:
+    case AutocompleteInput::UNKNOWN:
+    case AutocompleteInput::QUERY:
+    case AutocompleteInput::FORCED_QUERY:
       return kNonURLVerbatimRelevance;
 
-    case metrics::OmniboxInputType::URL:
+    case AutocompleteInput::URL:
       return 850;
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 int SearchProvider::GetKeywordVerbatimRelevance(
     bool* relevance_from_server) const {
@@ skipping 46 matching lines @@
     elapsed_time -= autocomplete_time;
   }
 
   const int score_discount =
       static_cast<int>(6.5 * std::pow(elapsed_time, 0.3));
 
   // Don't let scores go below 0.  Negative relevance scores are meaningful in
   // a different way.
   int base_score;
   if (is_primary_provider)
-    base_score = (input_.type() == metrics::OmniboxInputType::URL) ? 750 : 1050;
+    base_score = (input_.type() == AutocompleteInput::URL) ? 750 : 1050;
   else
     base_score = 200;
   return std::max(0, base_score - score_discount);
 }
 
 AutocompleteMatch SearchProvider::NavigationToMatch(
     const NavigationResult& navigation) {
   base::string16 input;
   const bool trimmed_whitespace = base::TrimWhitespace(
       navigation.from_keyword_provider() ?
@@ skipping 19 matching lines @@
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
   size_t inline_autocomplete_offset = (prefix == NULL) ?
       base::string16::npos : (match_start + input.length());
   match.fill_into_edit +=
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
           net::FormatUrl(navigation.url(), languages, format_types,
                          net::UnescapeRule::SPACES, NULL, NULL,
                          &inline_autocomplete_offset));
   // Preserve the forced query '?' prefix in |match.fill_into_edit|.
   // Otherwise, user edits to a suggestion would show non-Search results.
-  if (input_.type() == metrics::OmniboxInputType::FORCED_QUERY) {
+  if (input_.type() == AutocompleteInput::FORCED_QUERY) {
     match.fill_into_edit.insert(0, base::ASCIIToUTF16("?"));
     if (inline_autocomplete_offset != base::string16::npos)
       ++inline_autocomplete_offset;
   }
   if (inline_autocomplete_offset != base::string16::npos) {
     DCHECK(inline_autocomplete_offset <= match.fill_into_edit.length());
     match.inline_autocompletion =
         match.fill_into_edit.substr(inline_autocomplete_offset);
   }
   // An inlineable navsuggestion can only be the default match when there
@@ skipping 41 matching lines @@
     // Make the base64 encoded value URL and filename safe(see RFC 3548).
     std::replace(current_token_.begin(), current_token_.end(), '+', '-');
     std::replace(current_token_.begin(), current_token_.end(), '/', '_');
   }
 
   // Extend expiration time another 60 seconds.
   token_expiration_time_ = current_time + base::TimeDelta::FromSeconds(60);
 
   return current_token_;
 }