Remove AutocompleteInput Type and PageClassification.

chrome/browser/omnibox/omnibox_field_trial.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/omnibox/omnibox_field_trial.h"
 
 #include <cmath>
 #include <string>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
-#include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/common/variations/variation_ids.h"
+#include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/variations/active_field_trials.h"
 #include "components/variations/metrics_util.h"
 #include "components/variations/variations_associated_data.h"
 
+using metrics::OmniboxEventProto;
+
 namespace {
 
 typedef std::map<std::string, std::string> VariationParams;
 typedef HUPScoringParams::ScoreBuckets ScoreBuckets;
 
 // Field trial names.
 const char kHUPCullRedirectsFieldTrialName[] = "OmniboxHUPCullRedirects";
 const char kHUPCreateShorterMatchFieldTrialName[] =
     "OmniboxHUPCreateShorterMatch";
 const char kStopTimerFieldTrialName[] = "OmniboxStopTimer";
@@ skipping 266 matching lines @@
 
 bool OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial() {
   return HasDynamicFieldTrialGroupPrefix(
       kEnableZeroSuggestPersonalizedGroupPrefix) ||
       chrome_variations::GetVariationParamValue(
           kBundledExperimentFieldTrialName,
           kZeroSuggestVariantRule) == "Personalized";
 }
 
 bool OmniboxFieldTrial::ShortcutsScoringMaxRelevance(
-    AutocompleteInput::PageClassification current_page_classification,
+    OmniboxEventProto::PageClassification current_page_classification,
     int* max_relevance) {
   // The value of the rule is a string that encodes an integer containing
   // the max relevance.
   const std::string& max_relevance_str =
       OmniboxFieldTrial::GetValueForRuleInContext(
           kShortcutsScoringMaxRelevanceRule, current_page_classification);
   if (max_relevance_str.empty())
     return false;
   if (!base::StringToInt(max_relevance_str, max_relevance))
     return false;
   return true;
 }
 
 bool OmniboxFieldTrial::SearchHistoryPreventInlining(
-    AutocompleteInput::PageClassification current_page_classification) {
+    OmniboxEventProto::PageClassification current_page_classification) {
   return OmniboxFieldTrial::GetValueForRuleInContext(
       kSearchHistoryRule, current_page_classification) == "PreventInlining";
 }
 
 bool OmniboxFieldTrial::SearchHistoryDisable(
-    AutocompleteInput::PageClassification current_page_classification) {
+    OmniboxEventProto::PageClassification current_page_classification) {
   return OmniboxFieldTrial::GetValueForRuleInContext(
       kSearchHistoryRule, current_page_classification) == "Disable";
 }
 
 void OmniboxFieldTrial::GetDemotionsByType(
-    AutocompleteInput::PageClassification current_page_classification,
+    OmniboxEventProto::PageClassification current_page_classification,
     DemotionMultipliers* demotions_by_type) {
   demotions_by_type->clear();
   std::string demotion_rule = OmniboxFieldTrial::GetValueForRuleInContext(
       kDemoteByTypeRule, current_page_classification);
   // If there is no demotion rule for this context, then use the default
   // value for that context.  At the moment the default value is non-empty
   // only for the fakebox-focus context.
   if (demotion_rule.empty() &&
       (current_page_classification ==
-       AutocompleteInput::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS))
+       OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS))
     demotion_rule = "1:61,2:61,3:61,4:61,12:61";
 
   // The value of the DemoteByType rule is a comma-separated list of
   // {ResultType + ":" + Number} where ResultType is an AutocompleteMatchType::
   // Type enum represented as an integer and Number is an integer number
   // between 0 and 100 inclusive.   Relevance scores of matches of that result
   // type are multiplied by Number / 100.  100 means no change.
   base::StringPairs kv_pairs;
   if (base::SplitStringIntoKeyValuePairs(demotion_rule, ':', ',', &kv_pairs)) {
     for (base::StringPairs::const_iterator it = kv_pairs.begin();
@@ skipping 105 matching lines @@
 const char OmniboxFieldTrial::kHUPNewScoringVisitedCountScoreBucketsParam[] =
     "VisitedCountScoreBuckets";
 
 // Background and implementation details:
 //
 // Each experiment group in any field trial can come with an optional set of
 // parameters (key-value pairs).  In the bundled omnibox experiment
 // (kBundledExperimentFieldTrialName), each experiment group comes with a
 // list of parameters in the form:
 //   key=<Rule>:
-//       <AutocompleteInput::PageClassification (as an int)>:
+//       <OmniboxEventProto::PageClassification (as an int)>:
 //       <whether Instant Extended is enabled (as a 1 or 0)>
 //     (note that there are no linebreaks in keys; this format is for
 //      presentation only>
 //   value=<arbitrary string>
-// Both the AutocompleteInput::PageClassification and the Instant Extended
+// Both the OmniboxEventProto::PageClassification and the Instant Extended
 // entries can be "*", which means this rule applies for all values of the
 // matching portion of the context.
 // One example parameter is
 //   key=SearchHistory:6:1
 //   value=PreventInlining
 // This means in page classification context 6 (a search result page doing
 // search term replacement) with Instant Extended enabled, the SearchHistory
 // experiment should PreventInlining.
 //
 // When an exact match to the rule in the current context is missing, we
 // give preference to a wildcard rule that matches the instant extended
 // context over a wildcard rule that matches the page classification
 // context.  Hopefully, though, users will write their field trial configs
 // so as not to rely on this fall back order.
 //
 // In short, this function tries to find the value associated with key
 // |rule|:|page_classification|:|instant_extended|, failing that it looks up
 // |rule|:*:|instant_extended|, failing that it looks up
 // |rule|:|page_classification|:*, failing that it looks up |rule|:*:*,
 // and failing that it returns the empty string.
 std::string OmniboxFieldTrial::GetValueForRuleInContext(
     const std::string& rule,
-    AutocompleteInput::PageClassification page_classification) {
+    OmniboxEventProto::PageClassification page_classification) {
   VariationParams params;
   if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
                                              &params)) {
     return std::string();
   }
   const std::string page_classification_str =
       base::IntToString(static_cast<int>(page_classification));
   const std::string instant_extended =
       chrome::IsInstantExtendedAPIEnabled() ? "1" : "0";
   // Look up rule in this exact context.
   VariationParams::const_iterator it = params.find(
       rule + ":" + page_classification_str + ":" + instant_extended);
   if (it != params.end())
     return it->second;
   // Fall back to the global page classification context.
   it = params.find(rule + ":*:" + instant_extended);
   if (it != params.end())
     return it->second;
   // Fall back to the global instant extended context.
   it = params.find(rule + ":" + page_classification_str + ":*");
   if (it != params.end())
     return it->second;
   // Look up rule in the global context.
   it = params.find(rule + ":*:*");
   return (it != params.end()) ? it->second : std::string();
 }