Omnibox Field Trial: Make HQP Score Bookmarks More Highly

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>
 #include <set>
 
 #include <math.h>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/browser/bookmarks/bookmark_service.h"
+#include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace history {
 
 // ScoredHistoryMatch ----------------------------------------------------------
 
 // static
 const size_t ScoredHistoryMatch::kMaxVisitsToScore = 10u;
 const int ScoredHistoryMatch::kDaysToPrecomputeRecencyScoresFor = 366;
 const int ScoredHistoryMatch::kMaxRawTermScore = 30;
 float* ScoredHistoryMatch::raw_term_score_to_topicality_score_ = NULL;
 float* ScoredHistoryMatch::days_ago_to_recency_score_ = NULL;
 bool ScoredHistoryMatch::initialized_ = false;
+int ScoredHistoryMatch::bookmark_value_ = 1;
 bool ScoredHistoryMatch::also_do_hup_like_scoring_ = false;
 int ScoredHistoryMatch::max_assigned_score_for_non_inlineable_matches_ = -1;
 
 ScoredHistoryMatch::ScoredHistoryMatch()
     : raw_score_(0),
       can_inline_(false) {
-  if (!initialized_) {
-    InitializeAlsoDoHUPLikeScoringFieldAndMaxScoreField();
-    initialized_ = true;
-  }
+  Init();
 }
 
 ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
                                        const VisitInfoVector& visits,
                                        const std::string& languages,
                                        const string16& lower_string,
                                        const String16Vector& terms,
                                        const RowWordStarts& word_starts,
                                        const base::Time now,
                                        BookmarkService* bookmark_service)
     : HistoryMatch(row, 0, false, false),
       raw_score_(0),
       can_inline_(false) {
-  if (!initialized_) {
-    InitializeAlsoDoHUPLikeScoringFieldAndMaxScoreField();
-    initialized_ = true;
-  }
+  Init();
 
   GURL gurl = row.url();
   if (!gurl.is_valid())
     return;
 
   // Figure out where each search term appears in the URL and/or page title
   // so that we can score as well as provide autocomplete highlighting.
   string16 url = CleanUpUrlForMatching(gurl, languages);
   string16 title = CleanUpTitleForMatching(row.title());
   int term_num = 0;
@@ skipping 71 matching lines @@
     // makes it inlineable may be empty.
     DCHECK(best_inlineable_prefix != NULL);
     const int num_components_in_best_inlineable_prefix =
         best_inlineable_prefix->num_components;
     innermost_match = (num_components_in_best_inlineable_prefix ==
         num_components_in_best_prefix);
   }
 
   const float topicality_score =
       GetTopicalityScore(terms.size(), url, word_starts);
-  const float frecency_score = GetFrecency(now, visits);
+  const float frecency_score = GetFrecency(
+      now, (bookmark_service && bookmark_service->IsBookmarked(gurl)), visits);
   raw_score_ = GetFinalRelevancyScore(topicality_score, frecency_score);
   raw_score_ =
       (raw_score_ <= kint32max) ? static_cast<int>(raw_score_) : kint32max;
 
   if (also_do_hup_like_scoring_ && can_inline_) {
     // HistoryURL-provider-like scoring gives any match that is
     // capable of being inlined a certain minimum score.  Some of these
     // are given a higher score that lets them be shown in inline.
     // This test here derives from the test in
     // HistoryURLProvider::PromoteMatchForInlineAutocomplete().
@@ skipping 311 matching lines @@
     days_ago_to_recency_score_[days_ago] = unnormalized_recency_score / 100.0;
     if (days_ago > 0) {
       DCHECK_LE(days_ago_to_recency_score_[days_ago],
                 days_ago_to_recency_score_[days_ago - 1]);
     }
   }
 }
 
 // static
 float ScoredHistoryMatch::GetFrecency(const base::Time& now,
+                                      const bool bookmarked,
                                       const VisitInfoVector& visits) {
   // Compute the weighted average |value_of_transition| over the last at
   // most kMaxVisitsToScore visits, where each visit is weighted using
   // GetRecencyScore() based on how many days ago it happened.  Use
   // kMaxVisitsToScore as the denominator for the average regardless of
   // how many visits there were in order to penalize a match that has
   // fewer visits than kMaxVisitsToScore.
   const int total_sampled_visits = std::min(visits.size(), kMaxVisitsToScore);
   if (total_sampled_visits == 0)
     return 0.0f;
   float summed_visit_points = 0;
   for (int i = 0; i < total_sampled_visits; ++i) {
-    const int value_of_transition =
+    int value_of_transition =
         (visits[i].second == content::PAGE_TRANSITION_TYPED) ? 20 : 1;
+    if (bookmarked)
+      value_of_transition = std::max(value_of_transition, bookmark_value_);
     const float bucket_weight =
         GetRecencyScore((now - visits[i].first).InDays());
     summed_visit_points += (value_of_transition * bucket_weight);
   }
   return visits.size() * summed_visit_points / total_sampled_visits;
 }
 
 // static
 float ScoredHistoryMatch::GetFinalRelevancyScore(float topicality_score,
                                                  float frecency_score) {
@@ skipping 28 matching lines @@
   }
   // Linearly extrapolate so a score of 20 (or more) has a score of 1399.
   // (Scores above 20 are possible for URLs that have multiple term hits
   // in the URL and/or title and that are visited practically all
   // the time using typed visits.  We don't attempt to distinguish
   // between these very good results.)
   const float slope = (1399 - 1300) / (20.0f - 12.0f);
   return std::min(1399.0, 1300 + slope * (intermediate_score - 12.0));
 }
 
-void ScoredHistoryMatch::InitializeAlsoDoHUPLikeScoringFieldAndMaxScoreField() {
+void ScoredHistoryMatch::Init() {
+  if (initialized_)
+    return;
   also_do_hup_like_scoring_ = false;
   // When doing HUP-like scoring, don't allow a non-inlineable match
   // to beat the score of good inlineable matches.  This is a problem
   // because if a non-inlineable match ends up with the highest score
   // from HistoryQuick provider, all HistoryQuick matches get demoted
   // to non-inlineable scores (scores less than 1200).  Without
   // HUP-like-scoring, these results would actually come from the HUP
   // and not be demoted, thus outscoring the demoted HQP results.
   // When the HQP provides these, we need to clamp the non-inlineable
   // results to preserve this behavior.
   if (also_do_hup_like_scoring_) {
     max_assigned_score_for_non_inlineable_matches_ =
         HistoryURLProvider::kScoreForBestInlineableResult - 1;
   }
+  bookmark_value_ = OmniboxFieldTrial::HQPBookmarkValue();
+  initialized_ = true;
 }
 
 }  // namespace history