Move InMemoryURLIndex Caching Operations to FILE Thread

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 "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
 #include "chrome/browser/history/in_memory_url_index_cache.pb.h"
+#include "content/public/browser/notification_details.h"
 
 class HistoryQuickProviderTest;
 
 namespace in_memory_url_index {
 class InMemoryURLIndexCacheItem;
 }
 
 namespace history {
 
 namespace imui = in_memory_url_index;
 
 class HistoryDatabase;
+class InMemoryURLIndex;
+class URLIndexPrivateData;
+
+// A helper class to carry around a pointer to private data that is being
+// restored from the cache or rebuilt from the history database.
+class RefCountedURLIndexPrivateDataPtr
+    : public base::RefCountedThreadSafe<RefCountedURLIndexPrivateDataPtr> {
+ public:
+  RefCountedURLIndexPrivateDataPtr();
+
+  URLIndexPrivateData* get();
+  URLIndexPrivateData* release();

[brettw, 2012/03/12 04:37:40]

Delete release and reset.

[mrossetti, 2012/03/13 22:25:46]

This whole class is gone now.

+  void reset(URLIndexPrivateData* data);
+
+ private:
+  friend class base::RefCountedThreadSafe<RefCountedURLIndexPrivateDataPtr>;
+  virtual ~RefCountedURLIndexPrivateDataPtr();
+
+  scoped_ptr<URLIndexPrivateData> data_;

[brettw, 2012/03/12 04:37:40]

I don't think you should wrap a scoped_ptr with a reference counted object. Why
not just make your object refcounted?

[mrossetti, 2012/03/12 23:21:13]

Because I wanted the original class to be copy-able. No problem, though, I'll
get rid of this wacky container class and just write my own copy function.

On 2012/03/12 04:37:40, brettw wrote:

[mrossetti, 2012/03/13 22:25:46]

Done.

+};
 
 // 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;
@@ skipping 89 matching lines @@
   // descending score. The full results set (i.e. beyond the
   // |kItemsToScoreLimit| limit) will be retained and used for subsequent calls
   // to this function.
   ScoredHistoryMatches HistoryItemsForTerms(const string16& term_string);
 
   // Sets the |languages| to a list of language encodings with which the history
   // URLs and omnibox searches are interpreted, i.e. how each is broken
   // down into words and each word is broken down into characters.
   void set_languages(const std::string& languages) { languages_ = languages; }
 
-  // Restores the index's private data from the cache file stored in the
-  // profile directory and returns true if successful.
-  bool RestoreFromFile(const FilePath& file_path);
+  // Creates a new URLIndexPrivateData object, populates it from the contents
+  // of the cache file stored in |file_path|, and assigns it to
+  // |private_data_ptr|.
+  static void RestoreFromFileTask(
+      const FilePath& file_path,
+      scoped_refptr<RefCountedURLIndexPrivateDataPtr> private_data_ptr);
+
+  // 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.
+  static URLIndexPrivateData* RestoreFromFile(const FilePath& path);
 
   // 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.
   static URLIndexPrivateData* RebuildFromHistory(HistoryDatabase* history_db);
 
+  // Writes |private_data| as a cache file to |file_path| and returns success
+  // via |succeeded|.
+  static void WritePrivateDataToCacheFileTask(
+      scoped_ptr<URLIndexPrivateData> private_data,
+      const FilePath& file_path,
+      scoped_refptr<history::RefCountedBool> succeeded);
+
   // Caches the index private data and writes the cache file to the profile
-  // directory.
+  // directory.  Called by WritePrivateDataToCacheFileTask.
   bool SaveToFile(const FilePath& file_path);
 
   // Initializes all index data members in preparation for restoring the index
   // from the cache or a complete rebuild from the history database.
   void Clear();
 
+  // Returns true if there is no data in the index.
+  bool Empty() const;
+
   // 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);
 
   // Given a set of Char16s, finds words containing those characters.
   WordIDSet WordIDSetForTermChars(const Char16Set& term_chars);
 
   // Initializes the whitelist of URL schemes.
   static void InitializeSchemeWhitelist(std::set<std::string>* whitelist);
 
@@ skipping 62 matching lines @@
       const URLRow& row,
       const string16& lower_string,
       const String16Vector& terms_vector);
 
   // 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;
-
   // 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;
 
   // 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);
 
+  // Determines if |gurl| has a whitelisted scheme and returns true if so.
+  bool URLSchemeIsWhitelisted(const GURL& gurl) const;
+
   // 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 -------------------------------------
@@ skipping 39 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_