Launch HQP & HUP score changes.

components/omnibox/browser/omnibox_field_trial.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/browser/omnibox_field_trial.h"
 
 #include <cmath>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 // The maximum number of the autocomplete dynamic field trials (aka layers).
 const int kMaxAutocompleteDynamicFieldTrials = 5;
 
 
 // Concatenates the autocomplete dynamic field trial prefix with a field trial
 // ID to form a complete autocomplete field trial name.
 std::string DynamicFieldTrialName(int id) {
   return base::StringPrintf("%s%d", kAutocompleteDynamicFieldTrialPrefix, id);
 }
 
+void InitializeBucketsFromString(const std::string& bucket_string,
+                                 ScoreBuckets* score_buckets) {
+    // Clear the buckets.
+  score_buckets->buckets().clear();
+  base::StringPairs kv_pairs;
+  if (base::SplitStringIntoKeyValuePairs(bucket_string, ':', ',', &kv_pairs)) {
+    for (base::StringPairs::const_iterator it = kv_pairs.begin();
+         it != kv_pairs.end(); ++it) {
+      ScoreBuckets::CountMaxRelevance bucket;
+      base::StringToDouble(it->first, &bucket.first);
+      base::StringToInt(it->second, &bucket.second);
+      score_buckets->buckets().push_back(bucket);
+    }
+    std::sort(score_buckets->buckets().begin(),
+              score_buckets->buckets().end(),
+              std::greater<ScoreBuckets::CountMaxRelevance>());
+  }
+}
+
 void InitializeScoreBuckets(const VariationParams& params,
                             const char* relevance_cap_param,
                             const char* half_life_param,
                             const char* score_buckets_param,
+                            const char* use_decay_factor_param,
                             ScoreBuckets* score_buckets) {
   VariationParams::const_iterator it = params.find(relevance_cap_param);
   if (it != params.end()) {
     int relevance_cap;
     if (base::StringToInt(it->second, &relevance_cap))
       score_buckets->set_relevance_cap(relevance_cap);
   }
 
+  it = params.find(use_decay_factor_param);

[Bart N., 2015/08/26 23:01:25]

Can you add a unit test to omnibox_field_trial_test.cc and test the new param?

[Ashok vardhan, 2015/08/27 00:30:46]

Acknowledged.

+  if (it != params.end()) {
+    int use_decay_factor;
+    if (base::StringToInt(it->second, &use_decay_factor))
+      score_buckets->set_use_decay_factor(use_decay_factor);
+  }
+
   it = params.find(half_life_param);
   if (it != params.end()) {
     int half_life_days;
     if (base::StringToInt(it->second, &half_life_days))
       score_buckets->set_half_life_days(half_life_days);
   }
 
   it = params.find(score_buckets_param);
   if (it != params.end()) {
     // The value of the score bucket is a comma-separated list of
-    // {DecayedCount + ":" + MaxRelevance}.
-    base::StringPairs kv_pairs;
-    if (base::SplitStringIntoKeyValuePairs(it->second, ':', ',', &kv_pairs)) {
-      for (base::StringPairs::const_iterator it = kv_pairs.begin();
-           it != kv_pairs.end(); ++it) {
-        ScoreBuckets::CountMaxRelevance bucket;
-        base::StringToDouble(it->first, &bucket.first);
-        base::StringToInt(it->second, &bucket.second);
-        score_buckets->buckets().push_back(bucket);
-      }
-      std::sort(score_buckets->buckets().begin(),
-                score_buckets->buckets().end(),
-                std::greater<ScoreBuckets::CountMaxRelevance>());
-    }
+    // {DecayedCount/DecayedFactor + ":" + MaxRelevance}.
+    InitializeBucketsFromString(it->second, score_buckets);
   }
 }
 
 }  // namespace
 
 HUPScoringParams::ScoreBuckets::ScoreBuckets()
     : relevance_cap_(-1),
       half_life_days_(-1) {
 }
 
@@ skipping 161 matching lines @@
       // errors smartly.
       int k, v;
       base::StringToInt(it->first, &k);
       base::StringToInt(it->second, &v);
       (*demotions_by_type)[static_cast<AutocompleteMatchType::Type>(k)] =
           static_cast<float>(v) / 100.0f;
     }
   }
 }
 
+void OmniboxFieldTrial::GetDefaultHUPScoringParams(
+    HUPScoringParams* scoring_params) {
+  scoring_params->default_scoring_enabled = true;
+
+  ScoreBuckets* type_score_buckets = &scoring_params->typed_count_buckets;
+  type_score_buckets->set_half_life_days(30);
+  type_score_buckets->set_use_decay_factor(false);
+  const std::string& typed_count_score_buckets_str =
+    "1.0:1413,0.97:1390,0.93:1360,0.85:1340,0.72:1320,0.50:1250,0.0:1203";
+  InitializeBucketsFromString(typed_count_score_buckets_str,
+                              type_score_buckets);
+
+  ScoreBuckets* visit_score_buckets = &scoring_params->visited_count_buckets;
+  visit_score_buckets->set_half_life_days(30);
+  visit_score_buckets->set_use_decay_factor(false);
+  const std::string& visit_count_score_buckets_str = "4.0:790,0.5:590,0.0:100";
+  InitializeBucketsFromString(visit_count_score_buckets_str,
+                              visit_score_buckets);
+}
+
 void OmniboxFieldTrial::GetExperimentalHUPScoringParams(
     HUPScoringParams* scoring_params) {
   scoring_params->experimental_scoring_enabled = false;
 
   VariationParams params;
   if (!variations::GetVariationParams(kBundledExperimentFieldTrialName,
-                                      &params))
+                                      &params)) {
     return;
+  }
 
   VariationParams::const_iterator it = params.find(kHUPNewScoringEnabledParam);
   if (it != params.end()) {
     int enabled = 0;
     if (base::StringToInt(it->second, &enabled))
       scoring_params->experimental_scoring_enabled = (enabled != 0);
   }
 
   InitializeScoreBuckets(params, kHUPNewScoringTypedCountRelevanceCapParam,
       kHUPNewScoringTypedCountHalfLifeTimeParam,
       kHUPNewScoringTypedCountScoreBucketsParam,
+      kHUPNewScoringTypedCountUseDecayFactorParam,
       &scoring_params->typed_count_buckets);
   InitializeScoreBuckets(params, kHUPNewScoringVisitedCountRelevanceCapParam,
       kHUPNewScoringVisitedCountHalfLifeTimeParam,
       kHUPNewScoringVisitedCountScoreBucketsParam,
+      kHUPNewScoringVisitedCountUseDecayFactorParam,
       &scoring_params->visited_count_buckets);
 }
 
 int OmniboxFieldTrial::HQPBookmarkValue() {
   std::string bookmark_value_str =
       variations::GetVariationParamValue(kBundledExperimentFieldTrialName,
                                          kHQPBookmarkValueRule);
   if (bookmark_value_str.empty())
     return 10;
   // This is a best-effort conversion; we trust the hand-crafted parameters
@@ skipping 130 matching lines @@
     "PreventUWYTDefaultForNonURLInputs";
 
 const char OmniboxFieldTrial::kHUPNewScoringEnabledParam[] =
     "HUPExperimentalScoringEnabled";
 const char OmniboxFieldTrial::kHUPNewScoringTypedCountRelevanceCapParam[] =
     "TypedCountRelevanceCap";
 const char OmniboxFieldTrial::kHUPNewScoringTypedCountHalfLifeTimeParam[] =
     "TypedCountHalfLifeTime";
 const char OmniboxFieldTrial::kHUPNewScoringTypedCountScoreBucketsParam[] =
     "TypedCountScoreBuckets";
+const char OmniboxFieldTrial::kHUPNewScoringTypedCountUseDecayFactorParam[] =
+    "TypedCountUseDecayFactor";
 const char OmniboxFieldTrial::kHUPNewScoringVisitedCountRelevanceCapParam[] =
     "VisitedCountRelevanceCap";
 const char OmniboxFieldTrial::kHUPNewScoringVisitedCountHalfLifeTimeParam[] =
     "VisitedCountHalfLifeTime";
 const char OmniboxFieldTrial::kHUPNewScoringVisitedCountScoreBucketsParam[] =
     "VisitedCountScoreBuckets";
+const char OmniboxFieldTrial::kHUPNewScoringVisitedCountUseDecayFactorParam[] =
+    "VisitedCountUseDecayFactor";
 
 const char OmniboxFieldTrial::kHQPExperimentalScoringEnabledParam[] =
     "HQPExperimentalScoringEnabled";
 const char OmniboxFieldTrial::kHQPExperimentalScoringBucketsParam[] =
     "HQPExperimentalScoringBuckets";
 const char
     OmniboxFieldTrial::kHQPExperimentalScoringTopicalityThresholdParam[] =
       "HQPExperimentalScoringTopicalityThreshold";
 
 // static
@@ skipping 54 matching lines @@
   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();
 }