Componentize ScoredHistoryMatch

chrome/browser/autocomplete/history_quick_provider.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/autocomplete/history_quick_provider.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
+#include "chrome/browser/autocomplete/scored_history_match_builder_impl.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/in_memory_url_index.h"
-#include "chrome/browser/history/scored_history_match.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/in_memory_url_index_types.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_match_type.h"
 #include "components/omnibox/autocomplete_result.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/url_parse.h"
 #include "url/url_util.h"
 
 using history::InMemoryURLIndex;
 using history::ScoredHistoryMatch;
 using history::ScoredHistoryMatches;
 
+namespace {
+
+// Returns whether |url| is bookmarked in |bookmark_model| (which can be null
+// during testing). Used for ScoredHistoryMatchBuilderImpl.
+bool IsBookmarked(bookmarks::BookmarkModel* bookmark_model, const GURL& url) {
+  return bookmark_model && bookmark_model->IsBookmarked(url);
+}
+
+}  // namespace
+
 bool HistoryQuickProvider::disabled_ = false;
 
 HistoryQuickProvider::HistoryQuickProvider(Profile* profile)
     : HistoryProvider(profile, AutocompleteProvider::TYPE_HISTORY_QUICK),
       languages_(profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)) {
 }
 
 void HistoryQuickProvider::Start(const AutocompleteInput& input,
                                  bool minimal_changes,
                                  bool called_due_to_focus) {
@@ skipping 22 matching lines @@
           name, 1, 1000, 50, base::Histogram::kUmaTargetedHistogramFlag);
       counter->Add(static_cast<int>((end_time - start_time).InMilliseconds()));
     }
   }
 }
 
 HistoryQuickProvider::~HistoryQuickProvider() {}
 
 void HistoryQuickProvider::DoAutocomplete() {
   // Get the matching URLs from the DB.
-  ScoredHistoryMatches matches = GetIndex()->HistoryItemsForTerms(
-      autocomplete_input_.text(),
-      autocomplete_input_.cursor_position(),
-      AutocompleteProvider::kMaxMatches);
+  ScoredHistoryMatches matches;
+  {
+    ScoredHistoryMatchBuilderImpl builder(base::Bind(
+        &IsBookmarked,
+        base::Unretained(BookmarkModelFactory::GetForProfile(profile_))));
+    matches = GetIndex()->HistoryItemsForTerms(
+        autocomplete_input_.text(), autocomplete_input_.cursor_position(),
+        AutocompleteProvider::kMaxMatches, builder);
+  }
   if (matches.empty())
     return;
 
   // Figure out if HistoryURL provider has a URL-what-you-typed match
   // that ought to go first and what its score will be.
   bool will_have_url_what_you_typed_match_first = false;
   int url_what_you_typed_match_score = -1;  // undefined
   // These are necessary (but not sufficient) conditions for the omnibox
   // input to be a URL-what-you-typed match.  The username test checks that
   // either the username does not exist (a regular URL such as http://site/)
@@ skipping 85 matching lines @@
   // a URL-what-you-typed match.  (We want URL-what-you-typed matches for
   // visited URLs to beat out any longer URLs, no matter how frequently
   // they're visited.)  The strength of this reduction depends on the
   // likely score for the URL-what-you-typed result.
 
   // |template_url_service| or |template_url| can be NULL in unit tests.
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
   TemplateURL* template_url = template_url_service ?
       template_url_service->GetDefaultSearchProvider() : NULL;
-  int max_match_score = matches.begin()->raw_score();
+  int max_match_score = matches.begin()->raw_score;
   if (will_have_url_what_you_typed_match_first) {
     max_match_score = std::min(max_match_score,
         url_what_you_typed_match_score - 1);
   }
   for (ScoredHistoryMatches::const_iterator match_iter = matches.begin();
        match_iter != matches.end(); ++match_iter) {
     const ScoredHistoryMatch& history_match(*match_iter);
     // Culls results corresponding to queries from the default search engine.
     // These are low-quality, difficult-to-understand matches for users, and the
     // SearchProvider should surface past queries in a better way anyway.
     if (!template_url ||
         !template_url->IsSearchURL(history_match.url_info.url(),
                                    template_url_service->search_terms_data())) {
       // Set max_match_score to the score we'll assign this result:
-      max_match_score = std::min(max_match_score, history_match.raw_score());
+      max_match_score = std::min(max_match_score, history_match.raw_score);
       matches_.push_back(QuickMatchToACMatch(history_match, max_match_score));
       // Mark this max_match_score as being used:
       max_match_score--;
     }
   }
 }
 
 AutocompleteMatch HistoryQuickProvider::QuickMatchToACMatch(
     const ScoredHistoryMatch& history_match,
     int score) {
   const history::URLRow& info = history_match.url_info;
   AutocompleteMatch match(
       this, score, !!info.visit_count(),
-      history_match.url_matches().empty() ?
+      history_match.url_matches.empty() ?
           AutocompleteMatchType::HISTORY_TITLE :
           AutocompleteMatchType::HISTORY_URL);
   match.typed_count = info.typed_count();
   match.destination_url = info.url();
   DCHECK(match.destination_url.is_valid());
 
   // Format the URL autocomplete presentation.
   const net::FormatUrlTypes format_types = net::kFormatUrlOmitAll &
       ~(!history_match.match_in_scheme ? 0 : net::kFormatUrlOmitHTTP);
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           info.url(),
           net::FormatUrl(info.url(), languages_, format_types,
                          net::UnescapeRule::SPACES, NULL, NULL, NULL),
           ChromeAutocompleteSchemeClassifier(profile_));
   std::vector<size_t> offsets =
-      OffsetsFromTermMatches(history_match.url_matches());
+      OffsetsFromTermMatches(history_match.url_matches);
   base::OffsetAdjuster::Adjustments adjustments;
   match.contents = net::FormatUrlWithAdjustments(
       info.url(), languages_, format_types, net::UnescapeRule::SPACES, NULL,
       NULL, &adjustments);
   base::OffsetAdjuster::AdjustOffsets(adjustments, &offsets);
   history::TermMatches new_matches =
-      ReplaceOffsetsInTermMatches(history_match.url_matches(), offsets);
+      ReplaceOffsetsInTermMatches(history_match.url_matches, offsets);
   match.contents_class =
       SpansFromTermMatch(new_matches, match.contents.length(), true);
 
   // Set |inline_autocompletion| and |allowed_to_be_default_match| if possible.
-  if (history_match.can_inline()) {
+  if (history_match.can_inline) {
     DCHECK(!new_matches.empty());
     size_t inline_autocomplete_offset = new_matches[0].offset +
         new_matches[0].length;
     // |inline_autocomplete_offset| may be beyond the end of the
     // |fill_into_edit| if the user has typed an URL with a scheme and the
     // last character typed is a slash.  That slash is removed by the
     // FormatURLWithOffsets call above.
     if (inline_autocomplete_offset < match.fill_into_edit.length()) {
       match.inline_autocompletion =
           match.fill_into_edit.substr(inline_autocomplete_offset);
     }
     match.allowed_to_be_default_match = match.inline_autocompletion.empty() ||
         !PreventInlineAutocomplete(autocomplete_input_);
   }
   match.EnsureUWYTIsAllowedToBeDefault(
       autocomplete_input_.canonicalized_url(),
       TemplateURLServiceFactory::GetForProfile(profile_));
 
   // Format the description autocomplete presentation.
   match.description = info.title();
   match.description_class = SpansFromTermMatch(
-      history_match.title_matches(), match.description.length(), false);
+      history_match.title_matches, match.description.length(), false);
 
   match.RecordAdditionalInfo("typed count", info.typed_count());
   match.RecordAdditionalInfo("visit count", info.visit_count());
   match.RecordAdditionalInfo("last visit", info.last_visit());
 
   return match;
 }
 
 history::InMemoryURLIndex* HistoryQuickProvider::GetIndex() {
   if (index_for_testing_.get())
     return index_for_testing_.get();
 
   HistoryService* const history_service = HistoryServiceFactory::GetForProfile(
       profile_, ServiceAccessType::EXPLICIT_ACCESS);
   if (!history_service)
     return NULL;
 
   return history_service->InMemoryIndex();
 }