Omnibiox: Tweak HQP New Scoring and Re-Enable Field Trial

chrome/browser/history/scored_history_match.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 "chrome/browser/history/scored_history_match.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <numeric>
@@ skipping 129 matching lines @@
   float bookmark_boost =
       (bookmark_service && bookmark_service->IsBookmarked(gurl)) ? 10.0 : 0.0;
 
   if (use_new_scoring) {
     const float topicality_score = GetTopicalityScore(
         terms.size(), url, url_matches, title_matches, word_starts);
     const float recency_score = GetRecencyScore(
         (now - row.last_visit()).InDays());
     const float popularity_score = GetPopularityScore(
         row.typed_count() + bookmark_boost, row.visit_count());
-
-    // Combine recency, popularity, and topicality scores into one.
-    // Example of how this functions: Suppose the omnibox has one
-    // input term.  Suppose we have a URL that has 30 typed visits with
-    // the most recent being within a day and the omnibox input term
-    // has a single URL hostname hit at a word boundary.  Then this
-    // URL will score 1200 ( = 30 * 40.0).
-    raw_score = 40.0 * topicality_score * recency_score * popularity_score;
+    raw_score = GetFinalRelevancyScore(
+        topicality_score, recency_score, popularity_score);
     raw_score =
         (raw_score <= kint32max) ? static_cast<int>(raw_score) : kint32max;
   } else {  // "old" scoring
     // Get partial scores based on term matching. Note that the score for
     // each of the URL and title are adjusted by the fraction of the
     // terms appearing in each.
     int url_score = ScoreComponentForMatches(url_matches, url.length()) *
         std::min(url_matches.size(), terms.size()) / terms.size();
     int title_score =
         ScoreComponentForMatches(title_matches, title.length()) *
@@ skipping 310 matching lines @@
     // Advance next_word_starts until it's >= the position of the term
     // we're considering.
     while ((next_word_starts != end_word_starts) &&
            (*next_word_starts < iter->offset)) {
       ++next_word_starts;
       ++word_num;
     }
     if (word_num >= 10) break;  // only count the first ten words
     const bool at_word_boundary = (next_word_starts != end_word_starts) &&
         (*next_word_starts == iter->offset);
-    term_scores[iter->term_num] += at_word_boundary ? 8 : 2;
+    term_scores[iter->term_num] += at_word_boundary ? 8 : 0;
   }
   // TODO(mpearson): Restore logic for penalizing out-of-order matches.
   // (Perhaps discount them by 0.8?)
   // TODO(mpearson): Consider: if the earliest match occurs late in the string,
   // should we discount it?
   // TODO(mpearson): Consider: do we want to score based on how much of the
   // input string the input covers?  (I'm leaning toward no.)
 
   // Compute the topicality_score as the sum of transformed term_scores.
   float topicality_score = 0;
@@ skipping 92 matching lines @@
 }
 
 // static
 float ScoredHistoryMatch::GetPopularityScore(int typed_count,
                                              int visit_count) {
   // The max()s are to guard against database corruption.
   return (std::max(typed_count, 0) * 5.0 + std::max(visit_count, 0) * 3.0) /
       (5.0 + 3.0);
 }
 
+// static
+float ScoredHistoryMatch::GetFinalRelevancyScore(
+    float topicality_score, float recency_score, float popularity_score) {
+  // Here's how to interpret intermediate_score: Suppose the omnibox
+  // has one input term.  Suppose we have a URL that has 5 typed
+  // visits with the most recent being within a day and the omnibox
+  // input term has a single URL hostname hit at a word boundary.
+  // This URL will have an intermediate_score of 5.0 (= 1 topicality *
+  // 1 recency * 5 popularity).
+  float intermediate_score =
+      topicality_score * recency_score * popularity_score;
+  // The below code takes intermediate_score from [0, infinity) to
+  // relevancy scores in the range [0, 1400).
+  float attenuating_factor = 1.0;
+  if (intermediate_score < 4) {
+    // The formula in the final return line in this function only works if
+    // intermediate_score > 4.  For lower scores, we linearly interpolate
+    // between 0 and the formula when intermediate_score = 4.0.
+    attenuating_factor = intermediate_score / 4.0;
+    intermediate_score = 4.0;
+  }
+  DCHECK_GE(intermediate_score, 4.0);
+  return attenuating_factor * 1400.0 * (2.0 - exp(2.0 / intermediate_score));
+}
+
 void ScoredHistoryMatch::InitializeNewScoringField() {
   enum NewScoringOption {
     OLD_SCORING = 0,
     NEW_SCORING = 1,
     NEW_SCORING_AUTO_BUT_NOT_IN_FIELD_TRIAL = 2,
     NEW_SCORING_FIELD_TRIAL_DEFAULT_GROUP = 3,
     NEW_SCORING_FIELD_TRIAL_EXPERIMENT_GROUP = 4,
     NUM_OPTIONS = 5
   };
   // should always be overwritten
@@ skipping 46 matching lines @@
       new_scoring_option, NUM_OPTIONS);
 }
 
 void ScoredHistoryMatch::InitializeAlsoDoHUPLikeScoringField() {
   also_do_hup_like_scoring =
       AutocompleteFieldTrial::InHQPReplaceHUPScoringFieldTrial() &&
       AutocompleteFieldTrial::InHQPReplaceHUPScoringFieldTrialExperimentGroup();
 }
 
 }  // namespace history