Boost HQP Scores for Bookmarks

chrome/browser/history/url_index_private_data.h

 // 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.
 
 #ifndef CHROME_BROWSER_HISTORY_URL_INDEX_PRIVATE_DATA_H_
 #define CHROME_BROWSER_HISTORY_URL_INDEX_PRIVATE_DATA_H_
 
 #include <set>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
 #include "chrome/browser/history/in_memory_url_index_cache.pb.h"
 #include "chrome/browser/history/scored_history_match.h"
 #include "content/public/browser/notification_details.h"
 
 class HistoryQuickProviderTest;
+class Profile;
 
 namespace in_memory_url_index {
 class InMemoryURLIndexCacheItem;
 }
 
 namespace history {
 
 namespace imui = in_memory_url_index;
 
 class HistoryDatabase;
 class InMemoryURLIndex;
 class RefCountedBool;
 
 // Current version of the cache file.
 static const int kCurrentCacheFileVersion = 1;
 
 // A structure private to InMemoryURLIndex describing its internal data and
 // providing for restoring, rebuilding and updating that internal data. As
 // this class is for exclusive use by the InMemoryURLIndex class there should
 // be no calls from any other class.
 //
 // All public member functions are called on the main thread unless otherwise
 // annotated.
 class URLIndexPrivateData
     : public base::RefCountedThreadSafe<URLIndexPrivateData> {
  public:
-  URLIndexPrivateData();
+  explicit URLIndexPrivateData(Profile* profile);
 
   // Given a string16 in |term_string|, scans the history index and returns a
   // vector with all scored, matching history items. The |term_string| is
   // broken down into individual terms (words), each of which must occur in the
   // candidate history item's URL or page title for the item to qualify;
   // however, the terms do not necessarily have to be adjacent. Once we have
   // a set of candidates, they are filtered to insure that all |term_string|
   // terms, as separated by whitespace, occur within the candidate's URL
   // or page title. Scores are then calculated on no more than
   // |kItemsToScoreLimit| candidates, as the scoring of such a large number of
@@ skipping 19 matching lines @@
   // Deletes index data for the history item with the given |url|.
   // The item may not have actually been indexed, which is the case if it did
   // not previously meet minimum 'quick' criteria. Returns true if the index
   // was actually updated.
   bool DeleteURL(const GURL& url);
 
   // Creates a new URLIndexPrivateData object, populates it from the contents
   // of the cache file stored in |file_path|, and assigns it to |private_data|.
   // |languages| will be used to break URLs and page titles into words.
   static void RestoreFromFileTask(
+      Profile* profile,
       const FilePath& file_path,
       scoped_refptr<URLIndexPrivateData> private_data,
       const std::string& languages);
 
   // Constructs a new object by rebuilding its contents from the history
   // database in |history_db|. Returns the new URLIndexPrivateData which on
   // success will contain the rebuilt data but upon failure will be empty.
   // |languages| gives a list of language encodings by which the URLs and page
   // titles are broken down into words and characters.
   static scoped_refptr<URLIndexPrivateData> RebuildFromHistory(
+      Profile* profile,
       HistoryDatabase* history_db,
       const std::string& languages,
       const std::set<std::string>& scheme_whitelist);
 
   // Writes |private_data| as a cache file to |file_path| and returns success
   // via |succeeded|.
   static void WritePrivateDataToCacheFileTask(
       scoped_refptr<URLIndexPrivateData> private_data,
       const FilePath& file_path,
       scoped_refptr<RefCountedBool> succeeded);
@@ skipping 155 matching lines @@
   void SaveCharWordMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordIDHistoryMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveHistoryInfoMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordStartsMap(imui::InMemoryURLIndexCacheItem* cache) const;
 
   // Constructs a new object by restoring its contents from the file at |path|.
   // Returns the new URLIndexPrivateData which on success will contain the
   // restored data but upon failure will be empty.  |languages| will be used to
   // break URLs and page titles into words
   static scoped_refptr<URLIndexPrivateData> RestoreFromFile(
+      Profile* profile,
       const FilePath& path,
       const std::string& languages);
 
   // Decode a data structure from the protobuf |cache|. Return false if there
   // is any kind of failure. |languages| will be used to break URLs and page
   // titles into words
   bool RestorePrivateData(const imui::InMemoryURLIndexCacheItem& cache,
                           const std::string& languages);
   bool RestoreWordList(const imui::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordMap(const imui::InMemoryURLIndexCacheItem& cache);
   bool RestoreCharWordMap(const imui::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordIDHistoryMap(const imui::InMemoryURLIndexCacheItem& cache);
   bool RestoreHistoryInfoMap(const imui::InMemoryURLIndexCacheItem& cache);
   bool RestoreWordStartsMap(const imui::InMemoryURLIndexCacheItem& cache,
                             const std::string& languages);
 
   // Determines if |gurl| has a whitelisted scheme and returns true if so.
   static bool URLSchemeIsWhitelisted(const GURL& gurl,
                                      const std::set<std::string>& whitelist);
 
   // Cache of search terms.
   SearchTermCacheMap search_term_cache_;
 
+  Profile* profile_;
+
   // Start of data members that are cached -------------------------------------
 
   // The version of the cache file most recently used to restore this instance
   // of the private data. If the private data was rebuilt from the history
   // database this will be 0.
   int restored_cache_version_;
 
   // A list of all of indexed words. The index of a word in this list is the
   // ID of the word in the word_map_. It reduces the memory overhead by
   // replacing a potentially long and repeated string with a simple index.
@@ skipping 44 matching lines @@
   // Used for unit testing only. Records the number of candidate history items
   // at three stages in the index searching process.
   size_t pre_filter_item_count_;    // After word index is queried.
   size_t post_filter_item_count_;   // After trimming large result set.
   size_t post_scoring_item_count_;  // After performing final filter/scoring.
 };
 
 }  // namespace history
 
 #endif  // CHROME_BROWSER_HISTORY_URL_INDEX_PRIVATE_DATA_H_