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"
+// TODO(mrossetti): Remove these two includes one BookmarkService is available.

[Peter Kasting, 2012/09/05 19:06:30]

Nit: one -> once

I'm not actually sure what this comment means, or the similar one below.

[mrossetti, 2012/09/05 20:15:43]

Done. At some point, there will be an accessor to retrieve the BookmarkService
from the Profile. This note will remind me to fetch the BookmarkService instead
of the BookmarkModel once that happens.

On 2012/09/05 19:06:30, Peter Kasting wrote:

+#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/in_memory_url_index.h"
+#include "chrome/browser/profiles/profile.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"
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 using in_memory_url_index::InMemoryURLIndexCacheItem;
@@ skipping 20 matching lines @@
 
 // Algorithm Functions ---------------------------------------------------------
 
 // Comparison function for sorting search terms by descending length.
 bool LengthGreater(const string16& string_a, const string16& string_b) {
   return string_a.length() > string_b.length();
 }
 
 // Public Functions ------------------------------------------------------------
 
-URLIndexPrivateData::URLIndexPrivateData()
-    : restored_cache_version_(0),
+URLIndexPrivateData::URLIndexPrivateData(Profile* profile)
+    : profile_(profile),
+      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) {
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
@@ skipping 175 matching lines @@
       HistoryInfoMapItemHasURL(url));
   if (pos == history_info_map_.end())
     return false;
   RemoveRowFromIndex(pos->second);
   search_term_cache_.clear();  // This invalidates the cache.
   return true;
 }
 
 // static
 void URLIndexPrivateData::RestoreFromFileTask(
+    Profile* profile,
     const FilePath& file_path,
     scoped_refptr<URLIndexPrivateData> private_data,
     const std::string& languages) {
-  private_data = URLIndexPrivateData::RestoreFromFile(file_path, languages);
+  private_data =
+      URLIndexPrivateData::RestoreFromFile(profile, file_path, languages);
 }
 
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RebuildFromHistory(
+    Profile* profile,
     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(profile));
   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());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLWords",
                              rebuilt_data->word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLChars",
                              rebuilt_data->char_word_map_.size());
   return rebuilt_data;
 }
 
 // static
 void URLIndexPrivateData::WritePrivateDataToCacheFileTask(
     scoped_refptr<URLIndexPrivateData> private_data,
     const FilePath& file_path,
     scoped_refptr<RefCountedBool> succeeded) {
   DCHECK(private_data.get());
   DCHECK(!file_path.empty());
   succeeded->set_value(private_data->SaveToFile(file_path));
 }
 
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::Duplicate() const {
-  scoped_refptr<URLIndexPrivateData> data_copy = new URLIndexPrivateData;
+  scoped_refptr<URLIndexPrivateData> data_copy =
+      new URLIndexPrivateData(profile_);
   data_copy->word_list_ = word_list_;
   data_copy->available_words_ = available_words_;
   data_copy->word_map_ = word_map_;
   data_copy->char_word_map_ = char_word_map_;
   data_copy->word_id_history_map_ = word_id_history_map_;
   data_copy->history_id_word_map_ = history_id_word_map_;
   data_copy->history_info_map_ = history_info_map_;
   data_copy->word_starts_map_ = word_starts_map_;
   return data_copy;
   // Not copied:
@@ skipping 52 matching lines @@
 
 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());
+    // TODO(mrossetti): Change this to retrieve BookmarkService when available.
+    BookmarkService* bookmark_service =
+        BookmarkModelFactory::GetForProfile(private_data_.profile_);
     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 529 matching lines @@
     for (WordStarts::const_iterator i = word_starts.title_word_starts_.begin();
          i != word_starts.title_word_starts_.end(); ++i)
       map_entry->add_title_word_starts(*i);
   }
 }
 
 // Cache Restoring -------------------------------------------------------------
 
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RestoreFromFile(
+    Profile* profile,
     const FilePath& file_path,
     const std::string& languages) {
   base::TimeTicks beginning_time = base::TimeTicks::Now();
   if (!file_util::PathExists(file_path))
     return NULL;
   std::string data;
   // If there is no cache file then simply give up. This will cause us to
   // attempt to rebuild from the history database.
   if (!file_util::ReadFileToString(file_path, &data))
     return NULL;
 
-  scoped_refptr<URLIndexPrivateData> restored_data(new URLIndexPrivateData);
+  scoped_refptr<URLIndexPrivateData>
+      restored_data(new URLIndexPrivateData(profile));
   InMemoryURLIndexCacheItem index_cache;
   if (!index_cache.ParseFromArray(data.c_str(), data.size())) {
     LOG(WARNING) << "Failed to parse URLIndexPrivateData cache data read from "
                  << file_path.value();
     return restored_data;
   }
 
   if (!restored_data->RestorePrivateData(index_cache, languages))
     return NULL;
 
@@ skipping 191 matching lines @@
 }
 
 // static
 bool URLIndexPrivateData::URLSchemeIsWhitelisted(
     const GURL& gurl,
     const std::set<std::string>& whitelist) {
   return whitelist.find(gurl.scheme()) != whitelist.end();
 }
 
 }  // namespace history