Omnibox Field Trial: Make HQP Score Bookmarks More Highly

chrome/browser/history/scored_history_match.h

 // 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.
 
 #ifndef CHROME_BROWSER_HISTORY_SCORED_HISTORY_MATCH_H_
 #define CHROME_BROWSER_HISTORY_SCORED_HISTORY_MATCH_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/strings/string16.h"
 #include "chrome/browser/autocomplete/history_provider_util.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 
 class BookmarkService;
 
 namespace history {
 
 class ScoredHistoryMatchTest;
 
 // An HistoryMatch that has a score as well as metrics defining where in the
 // history item's URL and/or page title matches have occurred.
 class ScoredHistoryMatch : public history::HistoryMatch {
@@ skipping 32 matching lines @@
                                 const ScoredHistoryMatch& m2);
 
   // Accessors:
   int raw_score() const { return raw_score_; }
   const TermMatches& url_matches() const { return url_matches_; }
   const TermMatches& title_matches() const { return title_matches_; }
   bool can_inline() const { return can_inline_; }
 
  private:
   friend class ScoredHistoryMatchTest;
+  FRIEND_TEST(ScoredHistoryMatchTest, ScoringBookmarks);

[Peter Kasting, 2013/11/26 02:33:48]

Nit: Any way to add accessors to the base test class to avoid this additional
FRIEND_TEST line?

[Mark P, 2013/11/26 19:31:57]

Yes.  Done.  (Not that I think we should bother adding much code in order to
avoid FRIEND_TEST lines?  I don't see much harm in them.)

 
   // The number of days of recency scores to precompute.
   static const int kDaysToPrecomputeRecencyScoresFor;
 
   // The number of raw term score buckets use; raw term scores
   // greater this are capped at the score of the largest bucket.
   static const int kMaxRawTermScore;
 
   // Return a topicality score based on how many matches appear in the
   // url and the page's title and where they are (e.g., at word
   // boundaries).  Revises |url_matches_| and |title_matches_| in the
   // process so they only reflect matches used for scoring.  (For
   // instance, some mid-word matches are not given credit in scoring.)
   float GetTopicalityScore(const int num_terms,
                            const string16& cleaned_up_url,
                            const RowWordStarts& word_starts);
 
   // Helper function for GetTopicalityScore().
   // Returns |term_matches| after removing all matches that are not at a
   // word break that starts after position |start_pos|.  If |start_pos| is
   // string::npos, does no filtering and simply returns |term_matches|.
   static TermMatches FilterTermMatchesByWordStarts(
       const TermMatches& term_matches,
       const WordStarts& word_starts,
       const size_t start_pos);
 
-  // Precalculates raw_term_score_to_topicality_score, used in
+  // Precalculates raw_term_score_to_topicality_score_, used in
   // GetTopicalityScore().
   static void FillInTermScoreToTopicalityScoreArray();
 
   // Returns a recency score based on |last_visit_days_ago|, which is
   // how many days ago the page was last visited.
   static float GetRecencyScore(int last_visit_days_ago);
 
   // Pre-calculates days_ago_to_recency_numerator_, used in
   // GetRecencyScore().
   static void FillInDaysAgoToRecencyScoreArray();
 
   // Examines the first kMaxVisitsToScore and return a score (higher is
-  // better) based the rate of visits and how often those visits are
-  // typed navigations (i.e., explicitly invoked by the user).
-  // |now| is passed in to avoid unnecessarily recomputing it frequently.
+  // better) based the rate of visits, whether the page is bookmarked, and
+  // how often those visits are typed navigations (i.e., explicitly
+  // invoked by the user).  |now| is passed in to avoid unnecessarily
+  // recomputing it frequently.
   static float GetFrecency(const base::Time& now,
+                           const bool bookmarked,
                            const VisitInfoVector& visits);
 
   // Combines the two component scores into a final score that's
   // an appropriate value to use as a relevancy score.
   static float GetFinalRelevancyScore(
       float topicality_score,
       float frecency_score);
 
-  // Sets also_do_hup_like_scoring and
-  // max_assigned_score_for_non_inlineable_matches based on the field
+  // Sets also_do_hup_like_scoring_ and
+  // max_assigned_score_for_non_inlineable_matches_ based on the field
   // trial state.
   static void InitializeAlsoDoHUPLikeScoringFieldAndMaxScoreField();
 
+  // Sets |bookmark_value_| based on the field trial state.
+  static void InitializeBookmarkValue();
+
   // An interim score taking into consideration location and completeness
   // of the match.
   int raw_score_;
 
   // Both these TermMatches contain the set of matches that are considered
   // important.  At this time, that means they exclude mid-word matches
   // except in the hostname of the URL.  (Technically, during early
   // construction of ScoredHistoryMatch, they may contain all matches, but
   // unimportant matches are eliminated by GetTopicalityScore(), called
   // during construction.)
   // Term matches within the URL.
   TermMatches url_matches_;
   // Term matches within the page title.
   TermMatches title_matches_;
 
   // True if this is a candidate for in-line autocompletion.
   bool can_inline_;
 
   // Pre-computed information to speed up calculating recency scores.
-  // |days_ago_to_recency_score| is a simple array mapping how long
+  // |days_ago_to_recency_score_| is a simple array mapping how long
   // ago a page was visited (in days) to the recency score we should
   // assign it.  This allows easy lookups of scores without requiring
   // math.  This is initialized upon first use of GetRecencyScore(),
   // which calls FillInDaysAgoToRecencyScoreArray(),
   static float* days_ago_to_recency_score_;
 
   // Pre-computed information to speed up calculating topicality
-  // scores.  |raw_term_score_to_topicality_score| is a simple array
+  // scores.  |raw_term_score_to_topicality_score_| is a simple array
   // mapping how raw terms scores (a weighted sum of the number of
   // hits for the term, weighted by how important the hit is:
   // hostname, path, etc.) to the topicality score we should assign
   // it.  This allows easy lookups of scores without requiring math.
   // This is initialized upon first use of GetTopicalityScore(),
   // which calls FillInTermScoreToTopicalityScoreArray().
   static float* raw_term_score_to_topicality_score_;
 
   // Used so we initialize static variables only once (on first use).
   static bool initialized_;
 
+  // Untyped visits to bookmarked pages score this, compared to 1 for
+  // untyped visits to non-bookmarked pages and 20 for typed visits.
+  static int bookmark_value_;
+
   // If true, assign raw scores to be max(whatever it normally would be,
   // a score that's similar to the score HistoryURL provider would assign).
   // This variable is set in the constructor by examining the field trial
   // state.
   static bool also_do_hup_like_scoring_;
 
   // The maximum score that can be assigned to non-inlineable matches.
   // This is useful because often we want inlineable matches to come
   // first (even if they don't sometimes score as well as non-inlineable
   // matches) because if a non-inlineable match comes first than all matches
   // will get demoted later in HistoryQuickProvider to non-inlineable scores.
   // Set to -1 to indicate no maximum score.
   static int max_assigned_score_for_non_inlineable_matches_;
 };
 typedef std::vector<ScoredHistoryMatch> ScoredHistoryMatches;
 
 }  // namespace history
 
 #endif  // CHROME_BROWSER_HISTORY_SCORED_HISTORY_MATCH_H_