Boost HQP Scores for Bookmarks

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/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/api/bookmarks/bookmark_service.h"
 #include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace history {
 
 // The maximum score any candidate result can achieve.
 const int kMaxTotalScore = 1425;
 
@@ skipping 16 matching lines @@
   if (!initialized_) {
     InitializeNewScoringField();
     initialized_ = true;
   }
 }
 
 ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
                                        const string16& lower_string,
                                        const String16Vector& terms,
                                        const RowWordStarts& word_starts,
-                                       const base::Time now)
+                                       const base::Time now,
+                                       BookmarkService* bookmark_service)
     : HistoryMatch(row, 0, false, false),
       raw_score(0),
       can_inline(false) {
   if (!initialized_) {
     InitializeNewScoringField();
     initialized_ = true;
   }
 
   GURL gurl = row.url();
   if (!gurl.is_valid())
@@ skipping 35 matching lines @@
   //  3) AND the search string does not end in whitespace (making it look to
   //     the IMUI as though there is a single search term when actually there
   //     is a second, empty term).
   can_inline = !url_matches.empty() &&
       terms.size() == 1 &&
       (url_matches[0].offset == 0 ||
        URLPrefix::IsURLPrefix(url.substr(0, url_matches[0].offset))) &&
       !IsWhitespace(*(lower_string.rbegin()));
   match_in_scheme = can_inline && url_matches[0].offset == 0;
 
+  // Determine if the associated URLs is referenced by any bookmarks.
+  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(), row.visit_count());
+        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 =
         (raw_score <= kint32max) ? static_cast<int>(raw_score) : kint32max;
@@ skipping 14 matching lines @@
       return;
 
     // Determine scoring factors for the recency of visit, visit count and typed
     // count attributes of the URLRow.
     const int kDaysAgoLevel[] = { 1, 10, 20, 30 };
     int days_ago_value = ScoreForValue((base::Time::Now() -
         row.last_visit()).InDays(), kDaysAgoLevel);
     const int kVisitCountLevel[] = { 50, 30, 10, 5 };
     int visit_count_value = ScoreForValue(row.visit_count(), kVisitCountLevel);
     const int kTypedCountLevel[] = { 50, 30, 10, 5 };
-    int typed_count_value = ScoreForValue(row.typed_count(), kTypedCountLevel);
+    int typed_count_value = ScoreForValue(row.typed_count() + bookmark_boost,
+                                          kTypedCountLevel);
 
     // The final raw score is calculated by:
     //   - multiplying each factor by a 'relevance'
     //   - calculating the average.
     // Note that visit_count is reduced by typed_count because both are bumped
     // when a typed URL is recorded thus giving visit_count too much weight.
     const int kTermScoreRelevance = 4;
     const int kDaysAgoRelevance = 2;
     const int kVisitCountRelevance = 2;
     const int kTypedCountRelevance = 5;
@@ skipping 360 matching lines @@
   // Add a beacon to the logs that'll allow us to identify later what
   // new scoring state a user is in.  Do this by incrementing a bucket in
   // a histogram, where the bucket represents the user's new scoring state.
   UMA_HISTOGRAM_ENUMERATION(
       "Omnibox.HistoryQuickProviderNewScoringFieldTrialBeacon",
       new_scoring_option, NUM_OPTIONS);
 
 }
 
 }  // namespace history