Move InMemoryURLIndex outside of history namespace

chrome/browser/autocomplete/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_AUTOCOMPLETE_URL_INDEX_PRIVATE_DATA_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_URL_INDEX_PRIVATE_DATA_H_
 
 #include <set>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/autocomplete/in_memory_url_index_cache.pb.h"
 #include "chrome/browser/autocomplete/in_memory_url_index_types.h"
 #include "chrome/browser/autocomplete/scored_history_match.h"
 #include "chrome/browser/history/history_service.h"
 
 class HistoryQuickProviderTest;
 
 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 = 5;
 
 // 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
@@ skipping 32 matching lines @@
   // Adds the history item in |row| to the index if it does not already already
   // exist and it meets the minimum 'quick' criteria. If the row already exists
   // in the index then the index will be updated if the row still meets the
   // criteria, otherwise the row will be removed from the index. Returns true
   // if the index was actually updated. |languages| gives a list of language
   // encodings by which the URLs and page titles are broken down into words and
   // characters. |scheme_whitelist| is used to filter non-qualifying schemes.
   // |history_service| is used to schedule an update to the recent visits
   // component of this URL's entry in the index.
   bool UpdateURL(HistoryService* history_service,
-                 const URLRow& row,
+                 const history::URLRow& row,
                  const std::string& languages,
                  const std::set<std::string>& scheme_whitelist,
                  base::CancelableTaskTracker* tracker);
 
   // Updates the entry for |url_id| in the index, replacing its
   // recent visits information with |recent_visits|.  If |url_id|
   // is not in the index, does nothing.
-  void UpdateRecentVisits(URLID url_id,
-                          const VisitVector& recent_visits);
+  void UpdateRecentVisits(history::URLID url_id,
+                          const history::VisitVector& recent_visits);
 
   // Using |history_service| schedules an update (using the historyDB
   // thread) for the recent visits information for |url_id|.  Unless
   // something unexpectedly goes wrong, UdpateRecentVisits() should
   // eventually be called from a callback.
   void ScheduleUpdateRecentVisits(HistoryService* history_service,
-                                  URLID url_id,
+                                  history::URLID url_id,
                                   base::CancelableTaskTracker* tracker);
 
   // 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);
 
   // Constructs a new object by restoring its contents from the cache file
   // at |path|. Returns the new URLIndexPrivateData which on success will
   // contain the restored data but upon failure will be empty.  |languages|
   // is used to break URLs and page titles into words.  This function
   // should be run on the the file thread.
   static scoped_refptr<URLIndexPrivateData> RestoreFromFile(
       const base::FilePath& path,
       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(
-      HistoryDatabase* history_db,
+      history::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.
   static bool WritePrivateDataToCacheFileTask(
       scoped_refptr<URLIndexPrivateData> private_data,
       const base::FilePath& file_path);
 
   // Creates a copy of ourself.
   scoped_refptr<URLIndexPrivateData> Duplicate() const;
@@ skipping 84 matching lines @@
   // candidate results set is too large.
   class HistoryItemFactorGreater
       : public std::binary_function<HistoryID, HistoryID, void> {
    public:
     explicit HistoryItemFactorGreater(const HistoryInfoMap& history_info_map);
     ~HistoryItemFactorGreater();
 
     bool operator()(const HistoryID h1, const HistoryID h2);
 
    private:
-    const history::HistoryInfoMap& history_info_map_;
+    const HistoryInfoMap& history_info_map_;
   };
 
   // URL History indexing support functions.
 
   // Composes a set of history item IDs by intersecting the set for each word
   // in |unsorted_words|.
   HistoryIDSet HistoryIDSetFromWords(const String16Vector& unsorted_words);
 
   // Helper function to HistoryIDSetFromWords which composes a set of history
   // ids for the given term given in |term|.
   HistoryIDSet HistoryIDsForTerm(const base::string16& term);
 
   // Given a set of Char16s, finds words containing those characters.
   WordIDSet WordIDSetForTermChars(const Char16Set& term_chars);
 
   // Indexes one URL history item as described by |row|. Returns true if the
   // row was actually indexed. |languages| gives a list of language encodings by
   // which the URLs and page titles are broken down into words and characters.
   // |scheme_whitelist| is used to filter non-qualifying schemes.  If
   // |history_db| is not NULL then this function uses the history database
   // synchronously to get the URL's recent visits information.  This mode should
   // only be used on the historyDB thread.  If |history_db| is NULL, then
   // this function uses |history_service| to schedule a task on the
   // historyDB thread to fetch and update the recent visits
   // information.
-  bool IndexRow(HistoryDatabase* history_db,
+  bool IndexRow(history::HistoryDatabase* history_db,
                 HistoryService* history_service,
-                const URLRow& row,
+                const history::URLRow& row,
                 const std::string& languages,
                 const std::set<std::string>& scheme_whitelist,
                 base::CancelableTaskTracker* tracker);
 
   // 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|.
   // |languages| gives a list of language encodings by which the URLs and page
   // titles are broken down into words and characters.
-  void AddRowWordsToIndex(const URLRow& row,
+  void AddRowWordsToIndex(const history::URLRow& row,
                           RowWordStarts* word_starts,
                           const std::string& languages);
 
   // 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 base::string16& uni_word, HistoryID history_id);
 
   // Creates a new entry in the word/history map for |word_id| and add
   // |history_id| as the initial element of the word's set.
   void AddWordHistory(const base::string16& uni_word, HistoryID history_id);
 
   // Updates an existing entry in the word/history index by adding the
   // |history_id| to set for |word_id| in the word_id_history_map_.
   void UpdateWordHistory(WordID word_id, HistoryID history_id);
 
   // Adds |word_id| to |history_id|'s entry in the history/word map,
   // creating a new entry if one does not already exist.
   void AddToHistoryIDWordMap(HistoryID history_id, WordID word_id);
 
   // Removes |row| and all associated words and characters from the index.
-  void RemoveRowFromIndex(const URLRow& row);
+  void RemoveRowFromIndex(const history::URLRow& row);
 
   // Removes all words and characters associated with |row| from the index.
-  void RemoveRowWordsFromIndex(const URLRow& row);
+  void RemoveRowWordsFromIndex(const history::URLRow& row);
 
   // Clears |used_| for each item in the search term cache.
   void ResetSearchTermCache();
 
   // Caches the index private data and writes the cache file to the profile
   // directory.  Called by WritePrivateDataToCacheFileTask.
   bool SaveToFile(const base::FilePath& file_path);
 
   // 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;
+  void SavePrivateData(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveWordList(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveWordMap(in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveCharWordMap(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveWordIDHistoryMap(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveHistoryInfoMap(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
+  void SaveWordStartsMap(
+      in_memory_url_index::InMemoryURLIndexCacheItem* cache) const;
 
   // 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);
+  bool RestorePrivateData(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache,
+      const std::string& languages);
+  bool RestoreWordList(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
+  bool RestoreWordMap(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
+  bool RestoreCharWordMap(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
+  bool RestoreWordIDHistoryMap(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
+  bool RestoreHistoryInfoMap(
+      const in_memory_url_index::InMemoryURLIndexCacheItem& cache);
+  bool RestoreWordStartsMap(
+      const in_memory_url_index::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_;
 
   // Start of data members that are cached -------------------------------------
 
@@ skipping 52 matching lines @@
   // 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_AUTOCOMPLETE_URL_INDEX_PRIVATE_DATA_H_