Remove AutocompleteInput Type and PageClassification.

chrome/browser/omnibox/omnibox_field_trial_unittest.cc

 // Copyright (c) 2013 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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
-#include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/common/chrome_switches.h"
+#include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using metrics::OmniboxEventProto;
+
 class OmniboxFieldTrialTest : public testing::Test {
  public:
   OmniboxFieldTrialTest() {
     ResetFieldTrialList();
   }
 
   void ResetFieldTrialList() {
     // Destroy the existing FieldTrialList before creating a new one to avoid
     // a DCHECK.
     field_trial_list_.reset();
@@ skipping 16 matching lines @@
   static void VerifyDemotion(
       const OmniboxFieldTrial::DemotionMultipliers& demotions,
       AutocompleteMatchType::Type match_type,
       float expected_value);
 
   // EXPECT()s that OmniboxFieldTrial::GetValueForRuleInContext(|rule|,
   // |page_classification|) returns |rule_value|.
   static void ExpectRuleValue(
       const std::string& rule_value,
       const std::string& rule,
-      AutocompleteInput::PageClassification page_classification);
+      OmniboxEventProto::PageClassification page_classification);
 
  private:
   scoped_ptr<base::FieldTrialList> field_trial_list_;
 
   DISALLOW_COPY_AND_ASSIGN(OmniboxFieldTrialTest);
 };
 
 // static
 void OmniboxFieldTrialTest::VerifyDemotion(
     const OmniboxFieldTrial::DemotionMultipliers& demotions,
     AutocompleteMatchType::Type match_type,
     float expected_value) {
   OmniboxFieldTrial::DemotionMultipliers::const_iterator demotion_it =
       demotions.find(match_type);
   ASSERT_TRUE(demotion_it != demotions.end());
   EXPECT_FLOAT_EQ(expected_value, demotion_it->second);
 }
 
 // static
 void OmniboxFieldTrialTest::ExpectRuleValue(
     const std::string& rule_value,
     const std::string& rule,
-    AutocompleteInput::PageClassification page_classification) {
+    OmniboxEventProto::PageClassification page_classification) {
   EXPECT_EQ(rule_value,
             OmniboxFieldTrial::GetValueForRuleInContext(
                 rule, page_classification));
 }
 
 // Test if GetDisabledProviderTypes() properly parses various field trial
 // group names.
 TEST_F(OmniboxFieldTrialTest, GetDisabledProviderTypes) {
   EXPECT_EQ(0, OmniboxFieldTrial::GetDisabledProviderTypes());
 
@@ skipping 114 matching lines @@
     params[std::string(OmniboxFieldTrial::kDemoteByTypeRule) + ":3:*"] =
         "5:100";
     params[std::string(OmniboxFieldTrial::kDemoteByTypeRule) + ":*:*"] = "1:25";
     ASSERT_TRUE(chrome_variations::AssociateVariationParams(
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
   }
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
   OmniboxFieldTrial::DemotionMultipliers demotions_by_type;
   OmniboxFieldTrial::GetDemotionsByType(
-      AutocompleteInput::NTP, &demotions_by_type);
+      OmniboxEventProto::NTP, &demotions_by_type);
   ASSERT_EQ(2u, demotions_by_type.size());
   VerifyDemotion(demotions_by_type, AutocompleteMatchType::HISTORY_URL, 0.5);
   VerifyDemotion(demotions_by_type, AutocompleteMatchType::HISTORY_TITLE, 0.0);
   OmniboxFieldTrial::GetDemotionsByType(
-      AutocompleteInput::HOME_PAGE, &demotions_by_type);
+      OmniboxEventProto::HOME_PAGE, &demotions_by_type);
   ASSERT_EQ(1u, demotions_by_type.size());
   VerifyDemotion(demotions_by_type, AutocompleteMatchType::NAVSUGGEST, 1.0);
   OmniboxFieldTrial::GetDemotionsByType(
-      AutocompleteInput::BLANK, &demotions_by_type);
+      OmniboxEventProto::BLANK, &demotions_by_type);
   ASSERT_EQ(1u, demotions_by_type.size());
   VerifyDemotion(demotions_by_type, AutocompleteMatchType::HISTORY_URL, 0.25);
 }
 
 TEST_F(OmniboxFieldTrialTest, GetValueForRuleInContext) {
   {
     std::map<std::string, std::string> params;
     // Rule 1 has some exact matches and fallbacks at every level.
     params["rule1:1:0"] = "rule1-1-0-value";  // NTP
     params["rule1:3:0"] = "rule1-3-0-value";  // HOME_PAGE
@@ skipping 15 matching lines @@
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
   }
 
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
 
   if (chrome::IsInstantExtendedAPIEnabled()) {
     // Tests with Instant Extended enabled.
     // Tests for rule 1.
     ExpectRuleValue("rule1-4-1-value",
-                    "rule1", AutocompleteInput::OTHER);    // exact match
+                    "rule1", OmniboxEventProto::OTHER);    // exact match
     ExpectRuleValue("rule1-*-1-value",
-                    "rule1", AutocompleteInput::BLANK);    // partial fallback
+                    "rule1", OmniboxEventProto::BLANK);    // partial fallback
     ExpectRuleValue("rule1-*-1-value",
                     "rule1",
-                    AutocompleteInput::NTP);               // partial fallback
+                    OmniboxEventProto::NTP);               // partial fallback
 
     // Tests for rule 2.
     ExpectRuleValue("rule2-1-*-value",
                     "rule2",
-                    AutocompleteInput::NTP);               // partial fallback
+                    OmniboxEventProto::NTP);               // partial fallback
     ExpectRuleValue("rule2-*-*-value",
-                    "rule2", AutocompleteInput::OTHER);    // global fallback
+                    "rule2", OmniboxEventProto::OTHER);    // global fallback
 
     // Tests for rule 3.
     ExpectRuleValue("rule3-*-*-value",
                     "rule3",
-                    AutocompleteInput::HOME_PAGE);         // global fallback
+                    OmniboxEventProto::HOME_PAGE);         // global fallback
     ExpectRuleValue("rule3-*-*-value",
                     "rule3",
-                    AutocompleteInput::OTHER);             // global fallback
+                    OmniboxEventProto::OTHER);             // global fallback
 
     // Tests for rule 4.
     ExpectRuleValue("",
                     "rule4",
-                    AutocompleteInput::BLANK);             // no global fallback
+                    OmniboxEventProto::BLANK);             // no global fallback
     ExpectRuleValue("",
                     "rule4",
-                    AutocompleteInput::HOME_PAGE);         // no global fallback
+                    OmniboxEventProto::HOME_PAGE);         // no global fallback
 
     // Tests for rule 5 (a missing rule).
     ExpectRuleValue("",
-                    "rule5", AutocompleteInput::OTHER);    // no rule at all
+                    "rule5", OmniboxEventProto::OTHER);    // no rule at all
   } else {
     // Tests for rule 1.
     ExpectRuleValue("rule1-1-0-value",
-                    "rule1", AutocompleteInput::NTP);      // exact match
+                    "rule1", OmniboxEventProto::NTP);      // exact match
     ExpectRuleValue("rule1-1-0-value",
-                    "rule1", AutocompleteInput::NTP);      // exact match
+                    "rule1", OmniboxEventProto::NTP);      // exact match
     ExpectRuleValue("rule1-*-*-value",
-                    "rule1", AutocompleteInput::BLANK);    // fallback to global
+                    "rule1", OmniboxEventProto::BLANK);    // fallback to global
     ExpectRuleValue("rule1-3-0-value",
                     "rule1",
-                    AutocompleteInput::HOME_PAGE);         // exact match
+                    OmniboxEventProto::HOME_PAGE);         // exact match
     ExpectRuleValue("rule1-4-*-value",
-                    "rule1", AutocompleteInput::OTHER);    // partial fallback
+                    "rule1", OmniboxEventProto::OTHER);    // partial fallback
     ExpectRuleValue("rule1-*-*-value",
                     "rule1",
-                    AutocompleteInput::                    // fallback to global
+                    OmniboxEventProto::                    // fallback to global
                     SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT);
     // Tests for rule 2.
     ExpectRuleValue("rule2-*-0-value",
                     "rule2",
-                    AutocompleteInput::HOME_PAGE);         // partial fallback
+                    OmniboxEventProto::HOME_PAGE);         // partial fallback
     ExpectRuleValue("rule2-*-0-value",
-                    "rule2", AutocompleteInput::OTHER);    // partial fallback
+                    "rule2", OmniboxEventProto::OTHER);    // partial fallback
 
     // Tests for rule 3.
     ExpectRuleValue("rule3-*-*-value",
                     "rule3",
-                    AutocompleteInput::HOME_PAGE);         // fallback to global
+                    OmniboxEventProto::HOME_PAGE);         // fallback to global
     ExpectRuleValue("rule3-*-*-value",
-                    "rule3", AutocompleteInput::OTHER);    // fallback to global
+                    "rule3", OmniboxEventProto::OTHER);    // fallback to global
 
     // Tests for rule 4.
     ExpectRuleValue("",
-                    "rule4", AutocompleteInput::BLANK);    // no global fallback
+                    "rule4", OmniboxEventProto::BLANK);    // no global fallback
     ExpectRuleValue("",
                     "rule4",
-                    AutocompleteInput::HOME_PAGE);         // no global fallback
+                    OmniboxEventProto::HOME_PAGE);         // no global fallback
     ExpectRuleValue("rule4-4-0-value",
-                    "rule4", AutocompleteInput::OTHER);    // exact match
+                    "rule4", OmniboxEventProto::OTHER);    // exact match
 
     // Tests for rule 5 (a missing rule).
     ExpectRuleValue("",
-                    "rule5", AutocompleteInput::OTHER);    // no rule at all
+                    "rule5", OmniboxEventProto::OTHER);    // no rule at all
   }
 }
 
 TEST_F(OmniboxFieldTrialTest, HUPNewScoringFieldTrial) {
   {
     std::map<std::string, std::string> params;
     params[std::string(OmniboxFieldTrial::kHUPNewScoringEnabledParam)] = "1";
     params[std::string(
         OmniboxFieldTrial::kHUPNewScoringTypedCountRelevanceCapParam)] = "56";
     params[std::string(
@@ skipping 40 matching lines @@
 
   // No decay by default.
   EXPECT_EQ(1.0, buckets.HalfLifeTimeDecay(base::TimeDelta::FromDays(7)));
 
   buckets.set_half_life_days(7);
   EXPECT_EQ(0.5, buckets.HalfLifeTimeDecay(base::TimeDelta::FromDays(7)));
   EXPECT_EQ(0.25, buckets.HalfLifeTimeDecay(base::TimeDelta::FromDays(14)));
   EXPECT_EQ(1.0, buckets.HalfLifeTimeDecay(base::TimeDelta::FromDays(0)));
   EXPECT_EQ(1.0, buckets.HalfLifeTimeDecay(base::TimeDelta::FromDays(-1)));
 }