Remove AutocompleteInput Type and PageClassification.

chrome/browser/autocomplete/autocomplete_result.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_result.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/common/autocomplete_match_type.h"
-#include "components/metrics/proto/omnibox_input_type.pb.h"
+
+using metrics::OmniboxEventProto;
 
 namespace {
 
 // This class implements a special version of AutocompleteMatch::MoreRelevant
 // that allows matches of particular types to be demoted in AutocompleteResult.
 class CompareWithDemoteByType {
  public:
   CompareWithDemoteByType(
-      AutocompleteInput::PageClassification current_page_classification);
+      OmniboxEventProto::PageClassification current_page_classification);
 
   // Returns the relevance score of |match| demoted appropriately by
   // |demotions_by_type_|.
   int GetDemotedRelevance(const AutocompleteMatch& match);
 
   // Comparison function.
   bool operator()(const AutocompleteMatch& elem1,
                   const AutocompleteMatch& elem2);
 
  private:
   OmniboxFieldTrial::DemotionMultipliers demotions_;
 };
 
 CompareWithDemoteByType::CompareWithDemoteByType(
-    AutocompleteInput::PageClassification current_page_classification) {
+    OmniboxEventProto::PageClassification current_page_classification) {
   OmniboxFieldTrial::GetDemotionsByType(current_page_classification,
                                         &demotions_);
 }
 
 int CompareWithDemoteByType::GetDemotedRelevance(
     const AutocompleteMatch& match) {
   OmniboxFieldTrial::DemotionMultipliers::const_iterator demotion_it =
       demotions_.find(match.type);
   return (demotion_it == demotions_.end()) ?
       match.relevance : (match.relevance * demotion_it->second);
 }
 
 bool CompareWithDemoteByType::operator()(const AutocompleteMatch& elem1,
                                          const AutocompleteMatch& elem2) {
   // Compute demoted relevance scores for each match.
   const int demoted_relevance1 = GetDemotedRelevance(elem1);
   const int demoted_relevance2 = GetDemotedRelevance(elem2);
   // For equal-relevance matches, we sort alphabetically, so that providers
   // who return multiple elements at the same priority get a "stable" sort
   // across multiple updates.
   return (demoted_relevance1 == demoted_relevance2) ?
       (elem1.contents < elem2.contents) :
       (demoted_relevance1 > demoted_relevance2);
 }
 
 class DestinationSort {
  public:
   DestinationSort(
-      AutocompleteInput::PageClassification current_page_classification);
+      OmniboxEventProto::PageClassification current_page_classification);
   bool operator()(const AutocompleteMatch& elem1,
                   const AutocompleteMatch& elem2);
 
  private:
   CompareWithDemoteByType demote_by_type_;
 };
 
 DestinationSort::DestinationSort(
-    AutocompleteInput::PageClassification current_page_classification) :
+    OmniboxEventProto::PageClassification current_page_classification) :
     demote_by_type_(current_page_classification) {}
 
 bool DestinationSort::operator()(const AutocompleteMatch& elem1,
                                  const AutocompleteMatch& elem2) {
   // Sort identical destination_urls together.  Place the most relevant matches
   // first, so that when we call std::unique(), these are the ones that get
   // preserved.
   if (AutocompleteMatch::DestinationsEqual(elem1, elem2) ||
       (elem1.stripped_destination_url.is_empty() &&
        elem2.stripped_destination_url.is_empty())) {
@@ skipping 265 matching lines @@
     const AutocompleteInput& input,
     const AutocompleteMatch& match) {
   return ((input.type() == metrics::OmniboxInputType::UNKNOWN) &&
           (AutocompleteMatch::IsSearchType(match.type)) &&
           (match.transition != content::PAGE_TRANSITION_KEYWORD) &&
           (input.canonicalized_url() != match.destination_url)) ?
       input.canonicalized_url() : GURL();
 }
 
 void AutocompleteResult::DedupMatchesByDestination(
-      AutocompleteInput::PageClassification page_classification,
+      OmniboxEventProto::PageClassification page_classification,
       bool set_duplicate_matches,
       ACMatches* matches) {
   DestinationSort destination_sort(page_classification);
   // Sort matches such that duplicate matches are consecutive.
   std::sort(matches->begin(), matches->end(), destination_sort);
 
   if (set_duplicate_matches) {
     // Set duplicate_matches for the first match before erasing duplicate
     // matches.
     for (ACMatches::iterator i(matches->begin()); i != matches->end(); ++i) {
@@ skipping 38 matching lines @@
 bool AutocompleteResult::HasMatchByDestination(const AutocompleteMatch& match,
                                                const ACMatches& matches) {
   for (ACMatches::const_iterator i(matches.begin()); i != matches.end(); ++i) {
     if (i->destination_url == match.destination_url)
       return true;
   }
   return false;
 }
 
 void AutocompleteResult::MergeMatchesByProvider(
-    AutocompleteInput::PageClassification page_classification,
+    OmniboxEventProto::PageClassification page_classification,
     const ACMatches& old_matches,
     const ACMatches& new_matches) {
   if (new_matches.size() >= old_matches.size())
     return;
 
   size_t delta = old_matches.size() - new_matches.size();
   const int max_relevance = (new_matches.empty() ?
       matches_.front().relevance : new_matches[0].relevance) - 1;
   // Because the goal is a visibly-stable popup, rather than one that preserves
   // the highest-relevance matches, we copy in the lowest-relevance matches
   // first. This means that within each provider's "group" of matches, any
   // synchronous matches (which tend to have the highest scores) will
   // "overwrite" the initial matches from that provider's previous results,
   // minimally disturbing the rest of the matches.
   for (ACMatches::const_reverse_iterator i(old_matches.rbegin());
        i != old_matches.rend() && delta > 0; ++i) {
     if (!HasMatchByDestination(*i, new_matches)) {
       AutocompleteMatch match = *i;
       match.relevance = std::min(max_relevance, match.relevance);
       match.from_previous = true;
       matches_.push_back(match);
       delta--;
     }
   }
 }