Gather word-start Information to Aid in Scoring.

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_
 #pragma once
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
 #include "chrome/browser/history/in_memory_url_index_cache.pb.h"
 
 class HistoryQuickProviderTest;
 
 namespace in_memory_url_index {
 class InMemoryURLIndexCacheItem;
 }
 
 namespace history {
 
 namespace imui = in_memory_url_index;
 
 class HistoryDatabase;
 
+// Current version of the cache file.
+static const int kCurrentCacheFileVersion = 1;
+
 // A structure describing the InMemoryURLIndex's internal data and providing for
 // restoring, rebuilding and updating that internal data.
 class URLIndexPrivateData {
  public:
   URLIndexPrivateData();
   ~URLIndexPrivateData();
 
  private:
   friend class AddHistoryMatch;
   friend class ::HistoryQuickProviderTest;
@@ skipping 134 matching lines @@
   // criteria, otherwise the row will be removed from the index. Returns true
   // if the index was actually updated.
   bool UpdateURL(const URLRow& row);
 
   // Deletes indexing data for the history item with the URL given in |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);
 
-  // Parses and indexes the words in the URL and page title of |row|.
-  void AddRowWordsToIndex(const URLRow& row);
+  // Parses and indexes the words in the URL and page title of |row| and
+  // calculate the word starts in each, saving the starts in |word_starts|.
+  void AddRowWordsToIndex(const URLRow& row, WordStarts* word_starts);
 
   // Removes |row| and all associated words and characters from the index.
   void RemoveRowFromIndex(const URLRow& row);
 
   // Removes all words and characters associated with |row| from the index.
   void RemoveRowWordsFromIndex(const URLRow& row);
 
   // Given a single word in |uni_word|, adds a reference for the containing
   // history item identified by |history_id| to the index.
   void AddWordToIndex(const string16& uni_word, HistoryID history_id);
@@ skipping 23 matching lines @@
   // in the user input, 2) completeness of each term's match, 3) ordering
   // of the occurrence of each term (i.e. they appear in order), 4) last
   // visit time, and 5) number of visits.
   // This raw score allows the results to be ordered and can be used
   // to influence the final score calculated by the client of this
   // index. Returns a ScoredHistoryMatch structure with the raw score and
   // substring matching metrics.
   static ScoredHistoryMatch ScoredMatchForURL(
       const URLRow& row,
       const string16& lower_string,
-      const String16Vector& terms_vector);
+      const String16Vector& terms_vector,
+      const WordStarts& word_starts);
 
   // Calculates a component score based on position, ordering and total
   // substring match size using metrics recorded in |matches|. |max_length|
   // is the length of the string against which the terms are being searched.
   static int ScoreComponentForMatches(const TermMatches& matches,
                                       size_t max_length);
 
   // Determines if |gurl| has a whitelisted scheme and returns true if so.
   bool URLSchemeIsWhitelisted(const GURL& gurl) const;
 
+  // Sets the version of the cache file that will be saved when calling
+  // SavePrivateData(). For unit testing only.
+  void set_saved_cache_version(int version) { saved_cache_version_ = version; }
+
   // Encode a data structure into the protobuf |cache|.
   void SavePrivateData(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordList(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveCharWordMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveWordIDHistoryMap(imui::InMemoryURLIndexCacheItem* cache) const;
   void SaveHistoryInfoMap(imui::InMemoryURLIndexCacheItem* cache) const;
+  void SaveWordStartsMap(imui::InMemoryURLIndexCacheItem* cache) const;
 
   // Decode a data structure from the protobuf |cache|. Return false if there
   // is any kind of failure.
   bool RestorePrivateData(const imui::InMemoryURLIndexCacheItem& cache);
   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);
 
   // Cache of search terms.
   SearchTermCacheMap search_term_cache_;
 
   // Languages used during the word-breaking process during indexing.
   std::string languages_;
 
   // Only URLs with a whitelisted scheme are indexed.
   std::set<std::string> scheme_whitelist_;
 
   // 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.
   String16Vector word_list_;
 
   // A list of available words slots in |word_list_|. An available word slot
   // is the index of a unused word in word_list_ vector, also referred to as
   // a WordID. As URL visits are added or modified new words may be added to
   // the index, in which case any available words are used, if any, and then
   // words are added to the end of the word_list_. When URL visits are
@@ skipping 16 matching lines @@
 
   // A one-to-many mapping from a HistoryID to all WordIDs of words that occur
   // in the URL and/or page title of the history item referenced by that
   // HistoryID.
   HistoryIDWordMap history_id_word_map_;
 
   // A one-to-one mapping from HistoryID to the history item data governing
   // index inclusion and relevance scoring.
   HistoryInfoMap history_info_map_;
 
+  // A one-to-one mapping from HistoryID to the word starts detected in each
+  // item's URL and page title.
+  WordStartsMap word_starts_map_;
+
   // End of data members that are cached ---------------------------------------
 
+  // For unit testing only. Specifies the version of the cache file to be saved.
+  // Used only for testing upgrading of an older version of the cache upon
+  // restore.
+  int saved_cache_version_;
+
   // 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_