Add confidence to AutocompleteMatch.

chrome/browser/autocomplete/history_quick_provider.cc

 // Copyright (c) 2011 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/autocomplete/history_quick_provider.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 94 matching lines @@
   // inline autocompletd. Each such result gets the next available
   // |max_match_score|. Upon use of |max_match_score| it is decremented.
   // All subsequent matches must be clamped to retain match results ordering.
   int max_match_score = autocomplete_input_.prevent_inline_autocomplete() ?
       kMaxNonInliningScore : -1;
   for (ScoredHistoryMatches::const_iterator match_iter = matches.begin();
        match_iter != matches.end(); ++match_iter) {
     const ScoredHistoryMatch& history_match(*match_iter);
     if (history_match.raw_score > 0) {
       AutocompleteMatch ac_match = QuickMatchToACMatch(
-          history_match,
+          history_match, matches,
           PreventInlineAutocomplete(autocomplete_input_),
           &max_match_score);
+      UMA_HISTOGRAM_COUNTS_100("Autocomplete.Confidence_HistoryQuick",
+                               ac_match.confidence * 100);
       matches_.push_back(ac_match);
     }

[mrossetti, 2011/08/09 23:40:43]

You could calculate the denominator here and save it as an instance variable.

[dominich, 2011/08/10 16:10:13]

See other comment regarding potential algorithm changes.

   }
 }
 
 // static
 const int HistoryQuickProvider::kMaxNonInliningScore =
     AutocompleteResult::kLowestDefaultScore - 1;
 
 AutocompleteMatch HistoryQuickProvider::QuickMatchToACMatch(
     const ScoredHistoryMatch& history_match,
+    const ScoredHistoryMatches& history_matches,
     bool prevent_inline_autocomplete,
     int* max_match_score) {
   DCHECK(max_match_score);
   const history::URLRow& info = history_match.url_info;
   int score = CalculateRelevance(history_match, max_match_score);
-  AutocompleteMatch match(this, score, !!info.visit_count(),
+  float confidence = CalculateConfidence(history_match, history_matches);
+  AutocompleteMatch match(this, score, confidence, !!info.visit_count(),
                           history_match.url_matches.empty() ?
-                          AutocompleteMatch::HISTORY_URL :
-                          AutocompleteMatch::HISTORY_TITLE);
+                              AutocompleteMatch::HISTORY_URL :
+                              AutocompleteMatch::HISTORY_TITLE);
   match.destination_url = info.url();
   DCHECK(match.destination_url.is_valid());
 
   // Format the URL autocomplete presentation.
   std::vector<size_t> offsets =
       InMemoryURLIndex::OffsetsFromTermMatches(history_match.url_matches);
   match.contents =
       net::FormatUrlWithOffsets(info.url(), languages_, net::kFormatUrlOmitAll,
                                 UnescapeRule::SPACES, NULL, NULL, &offsets);
   history::TermMatches new_matches =
@@ skipping 46 matching lines @@
   // at the beginning of the result's URL and there is exactly one substring
   // match in the URL.
   int score = (history_match.can_inline) ? history_match.raw_score :
       std::min(kMaxNonInliningScore, history_match.raw_score);
   *max_match_score = ((*max_match_score < 0) ?
       score : std::min(score, *max_match_score)) - 1;
   return *max_match_score + 1;
 }
 
 // static
+float HistoryQuickProvider::CalculateConfidence(
+    const ScoredHistoryMatch& match,
+    const ScoredHistoryMatches& matches) {
+  float denominator = 0.0f;
+  for (ScoredHistoryMatches::const_iterator it = matches.begin();

[mrossetti, 2011/08/09 23:40:43]

Why not just calculate the 'denominator' up in DoAutocomplete() once all
qualifying matches have been collected?

+       it != matches.end(); ++it) {
+    denominator += it->raw_score;
+  }
+  DCHECK(denominator > 0);
+
+  return static_cast<float>(match.raw_score) / denominator;
+}
+
+// static
 ACMatchClassifications HistoryQuickProvider::SpansFromTermMatch(
     const history::TermMatches& matches,
     size_t text_length,
     bool is_url) {
   ACMatchClassification::Style url_style =
       is_url ? ACMatchClassification::URL : ACMatchClassification::NONE;
   ACMatchClassifications spans;
   if (matches.empty()) {
     if (text_length)
       spans.push_back(ACMatchClassification(0, url_style));
@@ skipping 10 matching lines @@
     do {
       offset += matches[i].length;
       ++i;
     } while ((i < match_count) && (offset == matches[i].offset));
     if (offset < text_length)
       spans.push_back(ACMatchClassification(offset, url_style));
   }
 
   return spans;
 }