HUP Experimental Scoring framework.

High level summary:
(a) Introduce a new set of Finch variation params and use it in the Omnibox bundled experiment
(b) Group together HUP scoring params in a HUPScoringParams struct and initialize it based on the new experiment params
(c) Modify HUP scoring by applying optional demotion 

This change is fairly safe because of the following reasons:
(1) It is disabled by default
(2) It never changes the relative order of HUP matches
(3) It can only demote a HUP match
(4) It is fairly isolated and unobtrusive

BUG=295756
TESTS=OmniboxFieldTrialTest,HistoryURLProviderTest

Review URL: https://codereview.chromium.org/23707058

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242569 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 106 insertions, 2 deletions

diff --git a/chrome/browser/omnibox/omnibox_field_trial.cc b/chrome/browser/omnibox/omnibox_field_trial.cc
index 8b6de02..93ec15b 100644
--- a/chrome/browser/omnibox/omnibox_field_trial.cc
+++ b/chrome/browser/omnibox/omnibox_field_trial.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 
+#include <cmath>
 #include <string>
 
 #include "base/metrics/field_trial.h"
@@ -11,6 +12,7 @@
 #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/metrics/variations/variation_ids.h"
@@ -19,6 +21,9 @@
 
 namespace {
 
+typedef std::map<std::string, std::string> VariationParams;
+typedef HUPScoringParams::ScoreBuckets ScoreBuckets;
+
 // Field trial names.
 const char kHUPCullRedirectsFieldTrialName[] = "OmniboxHUPCullRedirects";
 const char kHUPCreateShorterMatchFieldTrialName[] =
@@ -83,8 +88,66 @@ std::string DynamicFieldTrialName(int id) {
   return base::StringPrintf("%s%d", kAutocompleteDynamicFieldTrialPrefix, id);
 }
 
+void InitializeScoreBuckets(const VariationParams& params,
+                            const char* relevance_cap_param,
+                            const char* half_life_param,
+                            const char* score_buckets_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(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>());
+    }
+  }
+}
+
 }  // namespace
 
+HUPScoringParams::ScoreBuckets::ScoreBuckets()
+    : relevance_cap_(-1),
+      half_life_days_(-1) {
+}
+
+HUPScoringParams::ScoreBuckets::~ScoreBuckets() {
+}
+
+double HUPScoringParams::ScoreBuckets::HalfLifeTimeDecay(
+    const base::TimeDelta& elapsed_time) const {
+  double time_ms;
+  if ((half_life_days_ <= 0) ||
+      ((time_ms = elapsed_time.InMillisecondsF()) <= 0))
+    return 1.0;
+
+  const double half_life_intervals =
+      time_ms / base::TimeDelta::FromDays(half_life_days_).InMillisecondsF();
+  return pow(2.0, -half_life_intervals);
+}
 
 void OmniboxFieldTrial::ActivateStaticTrials() {
   DCHECK(!static_field_trials_initialized);
@@ -305,6 +368,32 @@ bool OmniboxFieldTrial::ReorderForLegalDefaultMatch(
       kReorderForLegalDefaultMatchRuleEnabled;
 }
 
+void OmniboxFieldTrial::GetExperimentalHUPScoringParams(
+    HUPScoringParams* scoring_params) {
+  scoring_params->experimental_scoring_enabled = false;
+
+  VariationParams params;
+  if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
+                                             &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,
+      &scoring_params->typed_count_buckets);
+  InitializeScoreBuckets(params, kHUPNewScoringVisitedCountRelevanceCapParam,
+      kHUPNewScoringVisitedCountHalfLifeTimeParam,
+      kHUPNewScoringVisitedCountScoreBucketsParam,
+      &scoring_params->visited_count_buckets);
+}
+
 int OmniboxFieldTrial::HQPBookmarkValue() {
   std::string bookmark_value_str = chrome_variations::
       GetVariationParamValue(kBundledExperimentFieldTrialName,
@@ -356,6 +445,21 @@ const char OmniboxFieldTrial::kHQPAllowMatchInSchemeRule[] =
 const char OmniboxFieldTrial::kReorderForLegalDefaultMatchRuleEnabled[] =
     "ReorderForLegalDefaultMatch";
 
+const char OmniboxFieldTrial::kHUPNewScoringEnabledParam[] =
+    "HUPExperimentalScoringEnabled";
+const char OmniboxFieldTrial::kHUPNewScoringTypedCountRelevanceCapParam[] =
+    "TypedCountRelevanceCap";
+const char OmniboxFieldTrial::kHUPNewScoringTypedCountHalfLifeTimeParam[] =
+    "TypedCountHalfLifeTime";
+const char OmniboxFieldTrial::kHUPNewScoringTypedCountScoreBucketsParam[] =
+    "TypedCountScoreBuckets";
+const char OmniboxFieldTrial::kHUPNewScoringVisitedCountRelevanceCapParam[] =
+    "VisitedCountRelevanceCap";
+const char OmniboxFieldTrial::kHUPNewScoringVisitedCountHalfLifeTimeParam[] =
+    "VisitedCountHalfLifeTime";
+const char OmniboxFieldTrial::kHUPNewScoringVisitedCountScoreBucketsParam[] =
+    "VisitedCountScoreBuckets";
+
 // Background and implementation details:
 //
 // Each experiment group in any field trial can come with an optional set of
@@ -392,7 +496,7 @@ const char OmniboxFieldTrial::kReorderForLegalDefaultMatchRuleEnabled[] =
 std::string OmniboxFieldTrial::GetValueForRuleInContext(
     const std::string& rule,
     AutocompleteInput::PageClassification page_classification) {
-  std::map<std::string, std::string> params;
+  VariationParams params;
   if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
                                              &params)) {
     return std::string();
@@ -402,7 +506,7 @@ std::string OmniboxFieldTrial::GetValueForRuleInContext(
   const std::string instant_extended =
       chrome::IsInstantExtendedAPIEnabled() ? "1" : "0";
   // Look up rule in this exact context.
-  std::map<std::string, std::string>::iterator it = params.find(
+  VariationParams::const_iterator it = params.find(
       rule + ":" + page_classification_str + ":" + instant_extended);
   if (it != params.end())
     return it->second;