Move Ownership of IMUI to HistoryService.

chrome/browser/history/in_memory_url_index.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_IN_MEMORY_URL_INDEX_H_
 #define CHROME_BROWSER_HISTORY_IN_MEMORY_URL_INDEX_H_
 #pragma once
 
 #include <functional>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/history_provider_util.h"
+#include "chrome/browser/cancelable_request.h"
+#include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_types.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/url_index_private_data.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 #include "sql/connection.h"
 
+class Profile;
+
 namespace base {
 class Time;
 }
 
 namespace in_memory_url_index {
 class InMemoryURLIndexCacheItem;
 }
 
 namespace history {
 
 namespace imui = in_memory_url_index;
 
-class URLDatabase;
+class HistoryDatabase;
+class URLIndexPrivateData;
+struct URLVisitedDetails;
+struct URLsModifiedDetails;
+struct URLsDeletedDetails;
 
 // The URL history source.
 // Holds portions of the URL database in memory in an indexed form.  Used to
 // quickly look up matching URLs for a given query string.  Used by
 // the HistoryURLProvider for inline autocomplete and to provide URL
 // matches to the omnibox.
 //
 // Note about multi-byte codepoints and the data structures in the
 // InMemoryURLIndex class: One will quickly notice that no effort is made to
 // insure that multi-byte character boundaries are detected when indexing the
 // words and characters in the URL history database except when converting
 // URL strings to lowercase. Multi-byte-edness makes no difference when
 // indexing or when searching the index as the final filtering of results
 // is dependent on the comparison of a string of bytes, not individual
 // characters. While the lookup of those bytes during a search in the
 // |char_word_map_| could serve up words in which the individual char16
 // occurs as a portion of a composite character the next filtering step
 // will eliminate such words except in the case where a single character
 // is being searched on and which character occurs as the second char16 of a
 // multi-char16 instance.
-class InMemoryURLIndex {
+class InMemoryURLIndex : public content::NotificationObserver {
  public:
-  // |history_dir| is a path to the directory containing the history database
-  // within the profile wherein the cache and transaction journals will be
-  // stored.
-  explicit InMemoryURLIndex(const FilePath& history_dir);
+  // |profile|, which may be NULL during unit testing, is used to register for
+  // history changes. |history_dir| is a path to the directory containing the
+  // history database within the profile wherein the cache and transaction
+  // journals will be stored. |languages| gives a list of language encodings by
+  // which URLs and omnibox searches are broken down into words and characters.
+  InMemoryURLIndex(Profile* profile,
+                   const FilePath& history_dir,
+                   const std::string& languages);
   virtual ~InMemoryURLIndex();
 
-  // Opens and indexes the URL history database. If the index private data
-  // cannot be restored from its cache file then it is rebuilt from the
-  // |history_db|. |languages| gives a list of language encodings by which URLs
-  // and omnibox searches are broken down into words and characters.
-  bool Init(URLDatabase* history_db, const std::string& languages);
+  // Opens and prepares the index of historical URL visits. If the index private
+  // data cannot be restored from its cache file then it is rebuilt from the
+  // history database.
+  void Init();
 
   // Signals that any outstanding initialization should be canceled and
   // flushes the cache to disk.
   void ShutDown();
 
-  // Reloads the history index from |history_db| ignoring any cache file that
-  // may be available, clears the cache and saves the cache after reloading.
-  bool ReloadFromHistory(history::URLDatabase* history_db);
-
   // Scans the history index and returns a vector with all scored, matching
   // history items. This entry point simply forwards the call on to the
   // URLIndexPrivateData class. For a complete description of this function
   // refer to that class.
   ScoredHistoryMatches HistoryItemsForTerms(const string16& term_string);
 
-  // Updates or adds an history item to the index if it meets the minimum
-  // 'quick' criteria.
-  void UpdateURL(URLID row_id, const URLRow& row);
-
-  // Deletes indexing data for an history item. The item may not have actually
-  // been indexed (which is the case if it did not previously meet minimum
-  // 'quick' criteria).
-  void DeleteURL(URLID row_id);
+  // Forwards to the URLIndexPrivateData. Returns true if the index was
+  // actually changed. For unit testing only.

[Peter Kasting, 2012/02/04 02:20:31]

Nit: If this is the case maybe these function names should have "ForTesting" on
the ends?  Although it looks like maybe you're actually calling these
internally... in which case I wonder if this comment shouldn't be updated or
removed, or maybe these should be private and the relevant test made a
friend...?

[mrossetti, 2012/02/04 04:30:53]

Ack! They weren't used anywhere else except the unit tests until I changed the
observer functions to call them.

So I've eliminated these functions, added passthrough functions to the unit test
class, and changed the observer functions back to directly calling the
private_data directly. A similar change was required in
history_quick_provider_unittest.c.

+  bool UpdateURL(const URLRow& row);
+  bool DeleteURL(const GURL& url);
 
  private:
   friend class InMemoryURLIndexTest;
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, CacheFilePath);
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, CacheSaveRestore);
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, HugeResultSet);
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, TitleSearch);
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, TypedCharacterCaching);
-  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexTest, WhitelistedURLs);
   FRIEND_TEST_ALL_PREFIXES(LimitedInMemoryURLIndexTest, Initialization);
+  FRIEND_TEST_ALL_PREFIXES(InMemoryURLIndexCacheTest, CacheFilePath);
 
   // Creating one of me without a history path is not allowed (tests excepted).
   InMemoryURLIndex();
 
+  // HistoryDBTask used to rebuild our private data from the history database.
+  class RebuildPrivateDataFromHistoryDBTask : public HistoryDBTask {
+   public:
+    explicit RebuildPrivateDataFromHistoryDBTask(InMemoryURLIndex* index);
+    virtual ~RebuildPrivateDataFromHistoryDBTask();
+
+    virtual bool RunOnDBThread(HistoryBackend* backend,
+                               history::HistoryDatabase* db) OVERRIDE;
+    virtual void DoneRunOnMainThread() OVERRIDE;
+
+   private:
+    InMemoryURLIndex* index_;  // Call back to this index at completion.
+    bool succeeded_;  // Indicates if the rebuild was successful.
+    scoped_ptr<URLIndexPrivateData> data_;  // The rebuilt private data.
+
+    DISALLOW_COPY_AND_ASSIGN(RebuildPrivateDataFromHistoryDBTask);
+  };
+
   // Initializes all index data members in preparation for restoring the index
   // from the cache or a complete rebuild from the history database.
   void ClearPrivateData();
 
-  // Construct a file path for the cache file within the same directory where
+  // Constructs a file path for the cache file within the same directory where
   // the history database is kept and saves that path to |file_path|. Returns
   // true if |file_path| can be successfully constructed. (This function
   // provided as a hook for unit testing.)
   bool GetCacheFilePath(FilePath* file_path);
 
+  // Restores the index's private data from the cache file stored in the
+  // profile directory.
+  void RestoreFromCacheFile();
+
+  // Restores private_data_ from the given |path|. Runs on the UI thread.
+  // Provided for unit testing so that a test cache file can be used.
+  void DoRestoreFromCacheFile(const FilePath& path);
+
+  // Schedules a history task to rebuild our private data from the history
+  // database.
+  void ScheduleRebuildFromHistory();
+
+  // Callback used by RebuildPrivateDataFromHistoryDBTask to signal completion
+  // or rebuilding our private data from the history database. |data| points to
+  // a new instance of the private data just rebuilt. This callback is only
+  // called upon a successful restore from the history database.
+  void DoneRebuidingPrivateDataFromHistoryDB(URLIndexPrivateData* data);
+
+  // Rebuilds the history index from the history database in |history_db|.
+  // Used for unit testing only.
+  void RebuildFromHistory(HistoryDatabase* history_db);
+
+  // Caches the index private data and writes the cache file to the profile
+  // directory.
+  void SaveToCacheFile();
+
+  // Saves private_data_ to the given |path|. Runs on the UI thread.
+  // Provided for unit testing so that a test cache file can be used.
+  void DoSaveToCacheFile(const FilePath& path);
+
+  // Handles notifications of history changes.
+  virtual void Observe(int notification_type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  // Notification handlers.
+  void OnURLVisited(const URLVisitedDetails* details);
+  void OnURLsModified(const URLsModifiedDetails* details);
+  void OnURLsDeleted(const URLsDeletedDetails* details);
+
+  // The profile, may be null when testing.
+  Profile* profile_;
+
   // Directory where cache file resides. This is, except when unit testing,
   // the same directory in which the profile's history database is found. It
   // should never be empty.
   FilePath history_dir_;
 
   // The index's durable private data.
   scoped_ptr<URLIndexPrivateData> private_data_;
 
-  // Set to true at shutdown when the cache has been written to disk. Used
-  // as a temporary safety check to insure that the cache is saved before
-  // the index has been destructed.
+  // Set to true once the shutdown process has begun.
+  bool shutdown_;
+
+  CancelableRequestConsumer cache_reader_consumer_;
+  content::NotificationRegistrar registrar_;
+
+  // Set to true when changes to the index have been made and the index needs
+  // to be cached. Set to false when the index has been cached. Used as a
+  // temporary safety check to insure that the cache is saved before the
+  // index has been destructed.
   // TODO(mrossetti): Eliminate once the transition to SQLite has been done.
   // http://crbug.com/83659
-  bool cached_at_shutdown_;
+  bool needs_to_be_cached_;
 
   DISALLOW_COPY_AND_ASSIGN(InMemoryURLIndex);
 };
 
 }  // namespace history
 
 #endif  // CHROME_BROWSER_HISTORY_IN_MEMORY_URL_INDEX_H_