Omnibox: Create Field Trial for HQP to Ignore Mid-Word Matches

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 38 matching lines @@
 // counts this score, which then gets modified slightly.  This number
 // is derived from the score of 900 + kMaxMatches used in HistoryURL
 // provider's CalculateRelevance() function for matches that are not
 // worthy of being inline autopleted.
 const int kBaseScoreForUntypedResultsInHUPLikeScoring = 900;
 
 // ScoredHistoryMatch ----------------------------------------------------------
 
 bool ScoredHistoryMatch::initialized_ = false;
 bool ScoredHistoryMatch::use_new_scoring = false;
+bool ScoredHistoryMatch::only_count_matches_at_word_boundaries = false;
 bool ScoredHistoryMatch::also_do_hup_like_scoring = false;
 
 ScoredHistoryMatch::ScoredHistoryMatch()
     : raw_score(0),
       can_inline(false) {
   if (!initialized_) {
     InitializeNewScoringField();
+    InitializeOnlyCountMatchesAtWordBoundariesField();
     InitializeAlsoDoHUPLikeScoringField();
     initialized_ = true;
   }
 }
 
 ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
                                        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_) {
     InitializeNewScoringField();
+    InitializeOnlyCountMatchesAtWordBoundariesField();
     InitializeAlsoDoHUPLikeScoringField();
     initialized_ = true;
   }
 
   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.
@@ skipping 62 matching lines @@
     // 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;
   } 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()) *
+    int url_score =
+        ScoreComponentForMatches(url_matches, word_starts.url_word_starts_,
+                                 url.length()) *
         std::min(url_matches.size(), terms.size()) / terms.size();
     int title_score =
-        ScoreComponentForMatches(title_matches, title.length()) *
+        ScoreComponentForMatches(title_matches, word_starts.title_word_starts_,
+                                 title.length()) *
         std::min(title_matches.size(), terms.size()) / terms.size();
     // Arbitrarily pick the best.
     // TODO(mrossetti): It might make sense that a term which appears in both
     // the URL and the Title should boost the score a bit.
     int term_score = std::max(url_score, title_score);
     if (term_score == 0)
       return;
 
     // Determine scoring factors for the recency of visit, visit count and typed
     // count attributes of the URLRow.
@@ skipping 102 matching lines @@
 
 ScoredHistoryMatch::~ScoredHistoryMatch() {}
 
 // std::accumulate helper function to add up TermMatches' lengths as used in
 // ScoreComponentForMatches
 int AccumulateMatchLength(int total, const TermMatch& match) {
   return total + match.length;
 }
 
 // static
-int ScoredHistoryMatch::ScoreComponentForMatches(const TermMatches& matches,
-                                                 size_t max_length) {
+int ScoredHistoryMatch::ScoreComponentForMatches(
+    const TermMatches& provided_matches,
+    const WordStarts& word_starts,
+    size_t max_length) {
+  if (provided_matches.empty())
+    return 0;
+
+  TermMatches matches_at_word_boundaries;
+  if (only_count_matches_at_word_boundaries) {
+    MakeTermMatchesOnlyAtWordBoundaries(
+        provided_matches, word_starts, &matches_at_word_boundaries);
+  }
+  // The actual matches we'll use for matching.  This is |provided_matches|
+  // with all the matches not at a word boundary removed (if told to do so).
+  const TermMatches& matches = only_count_matches_at_word_boundaries ?
+      matches_at_word_boundaries : provided_matches;
+
   if (matches.empty())
     return 0;
 
   // Score component for whether the input terms (if more than one) were found
   // in the same order in the match.  Start with kOrderMaxValue points divided
   // equally among (number of terms - 1); then discount each of those terms that
   // is out-of-order in the match.
   const int kOrderMaxValue = 1000;
   int order_value = kOrderMaxValue;
   if (matches.size() > 1) {
@@ skipping 37 matching lines @@
                   complete_value * kCompleteRelevance;
   raw_score /= (kOrderRelevance + kStartRelevance + kCompleteRelevance);
 
   // Scale the raw score into a single score component in the same manner as
   // used in ScoredMatchForURL().
   const int kTermScoreLevel[] = { 1000, 750, 500, 200 };
   return ScoreForValue(raw_score, kTermScoreLevel);
 }
 
 // static
+void ScoredHistoryMatch::MakeTermMatchesOnlyAtWordBoundaries(

[Bart N., 2012/11/29 17:32:26]

I think this particular method is worth a unit test, as it's non trivial.

[Mark P, 2012/11/29 19:36:48]

Done.

+    const TermMatches& matches,
+    const WordStarts& word_starts,
+    TermMatches* matches_at_word_boundaries) {
+  matches_at_word_boundaries->clear();
+  // Resize it to an upper-bound estimate of the correct size.
+  matches_at_word_boundaries->reserve(matches.size());
+  std::vector<size_t>::const_iterator next_word_starts = word_starts.begin(),
+      end_word_starts = word_starts.end();
+  for (TermMatches::const_iterator iter = matches.begin();
+       iter != matches.end(); ++iter) {
+    // 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;
+    }
+    if ((next_word_starts != end_word_starts) &&
+        (*next_word_starts == iter->offset)) {
+      // At word boundary: copy this element into |matches|.
+      matches_at_word_boundaries->push_back(*iter);
+    }
+  }
+}
+
+// static
 int ScoredHistoryMatch::ScoreForValue(int value, const int* value_ranks) {
   int i = 0;
   int rank_count = arraysize(kScoreRank);
   while ((i < rank_count) && ((value_ranks[0] < value_ranks[1]) ?
          (value > value_ranks[i]) : (value < value_ranks[i])))
     ++i;
   if (i >= rank_count)
     return 0;
   int score = kScoreRank[i];
   if (i > 0) {
@@ skipping 291 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);
 }
 
+void ScoredHistoryMatch::InitializeOnlyCountMatchesAtWordBoundariesField() {
+  only_count_matches_at_word_boundaries =
+      AutocompleteFieldTrial::
+          InHQPOnlyCountMatchesAtWordBoundariesFieldTrial() &&
+      AutocompleteFieldTrial::
+          InHQPOnlyCountMatchesAtWordBoundariesFieldTrialExperimentGroup();
+}
+
 void ScoredHistoryMatch::InitializeAlsoDoHUPLikeScoringField() {
   also_do_hup_like_scoring =
       AutocompleteFieldTrial::InHQPReplaceHUPScoringFieldTrial() &&
       AutocompleteFieldTrial::InHQPReplaceHUPScoringFieldTrialExperimentGroup();
 }
 
 }  // namespace history