Launch HQP & HUP score changes.

components/omnibox/browser/history_url_provider.cc

 // Copyright (c) 2012 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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 96 matching lines @@
 }
 
 // Calculates a new relevance score applying half-life time decaying to |count|
 // using |time_since_last_visit| and |score_buckets|.  This function will never
 // return a score higher than |undecayed_relevance|; in other words, it can only
 // demote the old score.
 double CalculateRelevanceUsingScoreBuckets(
     const HUPScoringParams::ScoreBuckets& score_buckets,
     const base::TimeDelta& time_since_last_visit,
     int undecayed_relevance,
-    int count) {
+    int undecayed_count) {
   // Back off if above relevance cap.
   if ((score_buckets.relevance_cap() != -1) &&
       (undecayed_relevance >= score_buckets.relevance_cap()))
     return undecayed_relevance;
 
   // Time based decay using half-life time.
-  double decayed_count = count;
+  double decayed_count = undecayed_count;
+  double decay_factor = score_buckets.HalfLifeTimeDecay(time_since_last_visit);
   if (decayed_count > 0)
-    decayed_count *= score_buckets.HalfLifeTimeDecay(time_since_last_visit);
+    decayed_count *= decay_factor;
 
-  // Find a threshold where decayed_count >= bucket.
+  // Find a threshold where decayed_count >= bucket. If buckets are based on
+  // decay factor, then use it correspondingly.
   const HUPScoringParams::ScoreBuckets::CountMaxRelevance* score_bucket = NULL;
   for (size_t i = 0; i < score_buckets.buckets().size(); ++i) {
     score_bucket = &score_buckets.buckets()[i];
-    if (decayed_count >= score_bucket->first)
-      break;  // Buckets are in descending order, so we can ignore the rest.
+    if (score_buckets.use_decay_factor()) {

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

This is invariant, so I suggest taking it out of the loop.

Something like:
const double factor = (score_buckets.use_decay_factor() ? decay_factor :
decay_count);

and then use 'factor' inside the loop.

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

Done.

+      if (decay_factor >= score_bucket->first) {
+        break;
+      }
+    } else {
+      if (decayed_count >= score_bucket->first) {
+        break;
+      }
+    }
   }
 
   return (score_bucket && (undecayed_relevance > score_bucket->second)) ?
       score_bucket->second : undecayed_relevance;
 }
 
 // Returns a new relevance score for the given |match| based on the
 // |old_relevance| score and |scoring_params|.  The new relevance score is
 // guaranteed to be less than or equal to |old_relevance|.  In other words, this
 // function can only demote a score, never boost it.  Returns |old_relevance| if
 // experimental scoring is disabled.
 int CalculateRelevanceScoreUsingScoringParams(
     const history::HistoryMatch& match,
     int old_relevance,
     const HUPScoringParams& scoring_params) {
-  if (!scoring_params.experimental_scoring_enabled)
+  if (!scoring_params.experimental_scoring_enabled &&
+      !scoring_params.default_scoring_enabled) {

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

I don't understand why we need default_scoring_enabled.

Can you simply make default_scoring params initialized before applying
experiment overrides? In this approach, defaults are always there and can be
optionally overridden.

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

Done.

     return old_relevance;
+  }
 
   const base::TimeDelta time_since_last_visit =
       base::Time::Now() - match.url_info.last_visit();
 
   int relevance = CalculateRelevanceUsingScoreBuckets(
       scoring_params.typed_count_buckets, time_since_last_visit, old_relevance,
       match.url_info.typed_count());
 
   // Additional demotion (on top of typed_count demotion) of URLs that were
   // never typed.
@@ skipping 295 matching lines @@
 }
 
 HistoryURLProviderParams::~HistoryURLProviderParams() {
 }
 
 HistoryURLProvider::HistoryURLProvider(AutocompleteProviderClient* client,
                                        AutocompleteProviderListener* listener)
     : HistoryProvider(AutocompleteProvider::TYPE_HISTORY_URL, client),
       listener_(listener),
       params_(NULL) {
+  // Initialize the default HUP scoring params.
+  OmniboxFieldTrial::GetDefaultHUPScoringParams(&scoring_params_);
   // Initialize HUP scoring params based on the current experiment.
   OmniboxFieldTrial::GetExperimentalHUPScoringParams(&scoring_params_);
 }
 
 void HistoryURLProvider::Start(const AutocompleteInput& input,
                                bool minimal_changes) {
   // NOTE: We could try hard to do less work in the |minimal_changes| case
   // here; some clever caching would let us reuse the raw matches from the
   // history DB without re-querying.  However, we'd still have to go back to
   // the history thread to mark these up properly, and if pass 2 is currently
@@ skipping 723 matching lines @@
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }