Parametrize Suggest polling strategy and delay. Also add a parameter

components/omnibox/omnibox_field_trial_unittest.cc

 // Copyright 2014 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 "components/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"
@@ skipping 47 matching lines @@
       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,
       OmniboxEventProto::PageClassification page_classification);
 
+  // EXPECTS that OmniboxFieldTrial::GetSuggestPollingStrategy returns

[H Fung, 2014/10/23 17:58:56]

EXPECT()s instead of EXPECTS similar to above?

[Bart N., 2014/10/23 19:19:58]

It was a copy from VerifyDemotion above, which I also fixed.

+  // |expected_from_last_keystroke| and |expected_delay_ms| for the given
+  // experiment params. If one the rule values is NULL, the corresponding
+  // variation parameter won't be set thus allowing to test the default
+  // behavior.
+  void VerifySuggestPollingStrategy(
+      const char* from_last_keystroke_rule_value,
+      const char* polling_delay_ms_rule_value,
+      bool expected_from_last_keystroke,
+      int expected_delay_ms);
+
  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,
     OmniboxEventProto::PageClassification page_classification) {
   EXPECT_EQ(rule_value,
             OmniboxFieldTrial::GetValueForRuleInContext(
                 rule, page_classification));
 }
 
+void OmniboxFieldTrialTest::VerifySuggestPollingStrategy(
+    const char* from_last_keystroke_rule_value,
+    const char* polling_delay_ms_rule_value,
+    bool expected_from_last_keystroke,
+    int expected_delay_ms) {
+  ResetFieldTrialList();
+  std::map<std::string, std::string> params;
+  if (from_last_keystroke_rule_value != NULL) {
+    params[std::string(
+        OmniboxFieldTrial::kMeasureSuggestPollingDelayFromLastKeystrokeRule)] =
+        from_last_keystroke_rule_value;
+  }
+  if (polling_delay_ms_rule_value != NULL) {
+    params[std::string(
+        OmniboxFieldTrial::kSuggestPollingDelayMsRule)] =
+        polling_delay_ms_rule_value;
+  }
+  ASSERT_TRUE(variations::AssociateVariationParams(
+      OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
+  base::FieldTrialList::CreateFieldTrial(
+      OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
+
+  bool from_last_keystroke;
+  int delay_ms;
+  OmniboxFieldTrial::GetSuggestPollingStrategy(&from_last_keystroke, &delay_ms);
+  EXPECT_EQ(expected_from_last_keystroke, from_last_keystroke);
+  EXPECT_EQ(expected_delay_ms, delay_ms);
+}
+
 // Test if GetDisabledProviderTypes() properly parses various field trial
 // group names.
 TEST_F(OmniboxFieldTrialTest, GetDisabledProviderTypes) {
   EXPECT_EQ(0, OmniboxFieldTrial::GetDisabledProviderTypes());
 
   {
     SCOPED_TRACE("Invalid groups");
     CreateTestTrial("AutocompleteDynamicTrial_0", "DisabledProviders_");
     EXPECT_EQ(0, OmniboxFieldTrial::GetDisabledProviderTypes());
     ResetFieldTrialList();
@@ skipping 266 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)));
 }
+
+TEST_F(OmniboxFieldTrialTest, DisableResultsCaching) {
+  EXPECT_FALSE(OmniboxFieldTrial::DisableResultsCaching());
+
+  {
+    std::map<std::string, std::string> params;
+    params[std::string(OmniboxFieldTrial::kDisableResultsCachingRule)] = "true";
+    ASSERT_TRUE(variations::AssociateVariationParams(
+        OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
+    base::FieldTrialList::CreateFieldTrial(
+        OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
+
+    EXPECT_TRUE(OmniboxFieldTrial::DisableResultsCaching());
+  }
+}
+
+TEST_F(OmniboxFieldTrialTest, GetSuggestPollingStrategy) {
+  // Invalid params.
+  VerifySuggestPollingStrategy(
+      "", "", false,
+      OmniboxFieldTrial::kDefaultMinimumTimeBetweenSuggestQueriesMs);
+  VerifySuggestPollingStrategy(
+      "foo", "-1", false,
+      OmniboxFieldTrial::kDefaultMinimumTimeBetweenSuggestQueriesMs);
+  VerifySuggestPollingStrategy(
+      "TRUE", "xyz", false,
+      OmniboxFieldTrial::kDefaultMinimumTimeBetweenSuggestQueriesMs);
+
+  // Default values.
+  VerifySuggestPollingStrategy(
+      NULL, NULL, false,
+      OmniboxFieldTrial::kDefaultMinimumTimeBetweenSuggestQueriesMs);
+
+  // Valid params.
+  VerifySuggestPollingStrategy("true", "50", true, 50);
+  VerifySuggestPollingStrategy(NULL, "35", false, 35);
+  VerifySuggestPollingStrategy(
+      "true", NULL, true,
+      OmniboxFieldTrial::kDefaultMinimumTimeBetweenSuggestQueriesMs);
+}