Boost HQP Scores for Bookmarks

chrome/browser/history/url_index_private_data.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/url_index_private_data.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <numeric>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/api/bookmarks/bookmark_service.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "net/base/net_util.h"
 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
@@ skipping 33 matching lines @@
 
 URLIndexPrivateData::URLIndexPrivateData()
     : restored_cache_version_(0),
       saved_cache_version_(kCurrentCacheFileVersion),
       pre_filter_item_count_(0),
       post_filter_item_count_(0),
       post_scoring_item_count_(0) {
 }
 
 ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
-    const string16& search_string) {
+    const string16& search_string,
+    BookmarkService* bookmark_service) {
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
   post_scoring_item_count_ = 0;
   // The search string we receive may contain escaped characters. For reducing
   // the index we need individual, lower-cased words, ignoring escapings. For
   // the final filtering we need whitespace separated substrings possibly
   // containing escaped characters.
   string16 lower_raw_string(base::i18n::ToLower(search_string));
   string16 lower_unescaped_string =
       net::UnescapeURLComponent(lower_raw_string,
@@ skipping 53 matching lines @@
   // "sort=pri&colspec=ID%20Mstone%20Release" we want to make sure that that
   // specific substring appears in the URL or page title.
 
   // We call these 'terms' (as opposed to 'words'; see above) as in this case
   // we only want to break up the search string on 'true' whitespace rather than
   // escaped whitespace. When the user types "colspec=ID%20Mstone Release" we
   // get two 'terms': "colspec=id%20mstone" and "release".
   history::String16Vector lower_raw_terms;
   Tokenize(lower_raw_string, kWhitespaceUTF16, &lower_raw_terms);
   scored_items = std::for_each(history_id_set.begin(), history_id_set.end(),
-      AddHistoryMatch(*this, lower_raw_string,
+      AddHistoryMatch(*this, bookmark_service, lower_raw_string,
                       lower_raw_terms, base::Time::Now())).ScoredMatches();
 
   // Select and sort only the top kMaxMatches results.
   if (scored_items.size() > AutocompleteProvider::kMaxMatches) {
     std::partial_sort(scored_items.begin(),
                       scored_items.begin() +
                           AutocompleteProvider::kMaxMatches,
                       scored_items.end(),
                       ScoredHistoryMatch::MatchScoreGreater);
       scored_items.resize(AutocompleteProvider::kMaxMatches);
@@ skipping 109 matching lines @@
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RebuildFromHistory(
     HistoryDatabase* history_db,
     const std::string& languages,
     const std::set<std::string>& scheme_whitelist) {
   if (!history_db)
     return NULL;
 
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
-  scoped_refptr<URLIndexPrivateData> rebuilt_data(new URLIndexPrivateData);
+  scoped_refptr<URLIndexPrivateData>
+      rebuilt_data(new URLIndexPrivateData);
   URLDatabase::URLEnumerator history_enum;
   if (!history_db->InitURLEnumeratorForSignificant(&history_enum))
     return NULL;
   for (URLRow row; history_enum.GetNextURL(&row); )
     rebuilt_data->IndexRow(row, languages, scheme_whitelist);
 
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexingTime",
                       base::TimeTicks::Now() - beginning_time);
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLHistoryItems",
                        rebuilt_data->history_id_word_map_.size());
@@ skipping 62 matching lines @@
 
 URLIndexPrivateData::SearchTermCacheItem::SearchTermCacheItem()
     : used_(true) {}
 
 URLIndexPrivateData::SearchTermCacheItem::~SearchTermCacheItem() {}
 
 // URLIndexPrivateData::AddHistoryMatch ----------------------------------------
 
 URLIndexPrivateData::AddHistoryMatch::AddHistoryMatch(
     const URLIndexPrivateData& private_data,
+    BookmarkService* bookmark_service,
     const string16& lower_string,
     const String16Vector& lower_terms,
     const base::Time now)
   : private_data_(private_data),
+    bookmark_service_(bookmark_service),
     lower_string_(lower_string),
     lower_terms_(lower_terms),
     now_(now) {}
 
 URLIndexPrivateData::AddHistoryMatch::~AddHistoryMatch() {}
 
 void URLIndexPrivateData::AddHistoryMatch::operator()(
     const HistoryID history_id) {
   HistoryInfoMap::const_iterator hist_pos =
       private_data_.history_info_map_.find(history_id);
   if (hist_pos != private_data_.history_info_map_.end()) {
     const URLRow& hist_item = hist_pos->second;
     WordStartsMap::const_iterator starts_pos =
         private_data_.word_starts_map_.find(history_id);
     DCHECK(starts_pos != private_data_.word_starts_map_.end());
     ScoredHistoryMatch match(hist_item, lower_string_, lower_terms_,
-                             starts_pos->second, now_);
+                             starts_pos->second, now_, bookmark_service_);
     if (match.raw_score > 0)
       scored_matches_.push_back(match);
   }
 }
 
 // URLIndexPrivateData::HistoryItemFactorGreater -------------------------------
 
 URLIndexPrivateData::HistoryItemFactorGreater::HistoryItemFactorGreater(
     const HistoryInfoMap& history_info_map)
     : history_info_map_(history_info_map) {
@@ skipping 752 matching lines @@
 }
 
 // static
 bool URLIndexPrivateData::URLSchemeIsWhitelisted(
     const GURL& gurl,
     const std::set<std::string>& whitelist) {
   return whitelist.find(gurl.scheme()) != whitelist.end();
 }
 
 }  // namespace history