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.

[Peter Kasting, 2015/08/27 19:21:40]

Nit: Wrong indent

[Ashok vardhan, 2015/08/27 19:51:38]

Acknowledged.

+  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);
+  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 != 0);
+  }
+
   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) {
+  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);
+  // Default typed count buckets based on decayed typed count. If url is
+  // 1-day older give score of 1390, 3 days older 0.93 and so on. Values are

[Peter Kasting, 2015/08/27 19:21:40]

Nit: Omit the sentence about "If url is 1-day older" as this just duplicates the
numbers below; it's the motivation for these numbers we're interested in.

[Ashok vardhan, 2015/08/27 19:51:38]

Done.

+  // chosen on idea of demoting the URLs with lower counts based on the
+  // number of days back they visited.

[Peter Kasting, 2015/08/27 19:21:40]

Nit: This last sentence is kind of vague.  It's sort of clear from the general
idea of these buckets that we're demoting URLs with lower counts like this,
what's more interesting is how we obtained these numbers.  For example, "The
values here are based on the results of field trials to determine what maximized
overall result quality." (If that's actually true.)

[Ashok vardhan, 2015/08/27 19:51:38]

Done.

+  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);
+  // High number of visits - 790, at least 1 in 30 days - 590 otherwise give 100
+  // (which practically means to drop the urls on to floor).

[Peter Kasting, 2015/08/27 19:21:40]

Similar comment applies here.

[Ashok vardhan, 2015/08/27 19:51:38]

Done.

+  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))
     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();
 }