Omnibox: Improve HQP Scoring for Terms that Start with Punctuation

components/omnibox/browser/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 "components/omnibox/browser/scored_history_match.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 455 matching lines @@
   url_matches = FilterTermMatchesByWordStarts(
       url_matches, terms_to_word_starts_offsets, word_starts.url_word_starts_,
       end_of_hostname_pos, std::string::npos);
   if (colon_pos != std::string::npos) {
     // Also filter matches not at a word boundary and in the scheme.
     url_matches = FilterTermMatchesByWordStarts(
         url_matches, terms_to_word_starts_offsets, word_starts.url_word_starts_,
         0, colon_pos);
   }
   for (const auto& url_match : url_matches) {
-    const size_t term_offset = terms_to_word_starts_offsets[url_match.term_num];
+    // Calculate the offset in the URL string where the meaningful (word) part
+    // of the term starts.  This takes into account times when a term starts
+    // with punctuation such as "/foo".
+    const size_t term_word_offset =
+        url_match.offset + terms_to_word_starts_offsets[url_match.term_num];
     // Advance next_word_starts until it's >= the position of the term we're
     // considering (adjusted for where the word begins within the term).
     while ((next_word_starts != end_word_starts) &&
-           (*next_word_starts < (url_match.offset + term_offset))) {
+           (*next_word_starts < term_word_offset)) {
       ++next_word_starts;
     }
     const bool at_word_boundary =
         (next_word_starts != end_word_starts) &&
-        (*next_word_starts == url_match.offset + term_offset);
+        (*next_word_starts == term_word_offset);
     if ((question_mark_pos != std::string::npos) &&
-        (url_match.offset > question_mark_pos)) {
+        (term_word_offset >= question_mark_pos)) {
       // The match is in a CGI ?... fragment.
       DCHECK(at_word_boundary);
       term_scores[url_match.term_num] += 5;
     } else if ((end_of_hostname_pos != std::string::npos) &&
-               (url_match.offset > end_of_hostname_pos)) {
+               (term_word_offset >= end_of_hostname_pos)) {
       // The match is in the path.
       DCHECK(at_word_boundary);
       term_scores[url_match.term_num] += 8;
     } else if ((colon_pos == std::string::npos) ||
-               (url_match.offset > colon_pos)) {
+               (term_word_offset >= colon_pos)) {
       // The match is in the hostname.
       if ((last_part_of_hostname_pos == std::string::npos) ||
-          (url_match.offset < last_part_of_hostname_pos)) {
+          (term_word_offset < last_part_of_hostname_pos)) {
         // Either there are no dots in the hostname or this match isn't
         // the last dotted component.
         term_scores[url_match.term_num] += at_word_boundary ? 10 : 2;
       } else {
         // The match is in the last part of a dotted hostname (usually this
         // is the top-level domain .com, .net, etc.).
         if (allow_tld_matches_)
           term_scores[url_match.term_num] += at_word_boundary ? 10 : 0;
       }
     } else {
       // The match is in the protocol (a.k.a. scheme).
       // Matches not at a word boundary should have been filtered already.
       DCHECK(at_word_boundary);
       match_in_scheme = true;
       if (allow_scheme_matches_)
         term_scores[url_match.term_num] += 10;
     }
   }
   // Now do the analogous loop over all matches in the title.
   next_word_starts = word_starts.title_word_starts_.begin();
   end_word_starts = word_starts.title_word_starts_.end();
   size_t word_num = 0;
   title_matches = FilterTermMatchesByWordStarts(
       title_matches, terms_to_word_starts_offsets,
       word_starts.title_word_starts_, 0, std::string::npos);
   for (const auto& title_match : title_matches) {
-    const size_t term_offset =
-        terms_to_word_starts_offsets[title_match.term_num];
+    // Calculate the offset in the title string where the meaningful (word) part
+    // of the term starts.  This takes into account times when a term starts
+    // with punctuation such as "/foo".
+    const size_t term_word_offset =
+        title_match.offset + terms_to_word_starts_offsets[title_match.term_num];
     // Advance next_word_starts until it's >= the position of the term we're
     // considering (adjusted for where the word begins within the term).
     while ((next_word_starts != end_word_starts) &&
-           (*next_word_starts < (title_match.offset + term_offset))) {
+           (*next_word_starts < term_word_offset)) {
       ++next_word_starts;
       ++word_num;
     }
     if (word_num >= num_title_words_to_allow_)
       break;  // only count the first ten words
     DCHECK(next_word_starts != end_word_starts);
-    DCHECK_EQ(*next_word_starts, title_match.offset + term_offset)
+    DCHECK_EQ(*next_word_starts, term_word_offset)
         << "not at word boundary";
     term_scores[title_match.term_num] += 8;
   }
   // 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.)
 
@@ skipping 165 matching lines @@
           base::StringToDouble(it->first, &bucket.first);
       DCHECK(is_valid_intermediate_score);
       bool is_valid_hqp_score = base::StringToInt(it->second, &bucket.second);
       DCHECK(is_valid_hqp_score);
       hqp_buckets->push_back(bucket);
     }
     return true;
   }
   return false;
 }