Replace HistoryQuickProvider protobuf-based caching with an SQLite-based database.

chrome/browser/history/history.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_HISTORY_H_
 #define CHROME_BROWSER_HISTORY_HISTORY_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 93 matching lines @@
   // Must call Init after construction.
   explicit HistoryService(Profile* profile);
   // The empty constructor is provided only for testing.
   HistoryService();
 
   // Initializes the history service, returning true on success. On false, do
   // not call any other functions. The given directory will be used for storing
   // the history files. The BookmarkService is used when deleting URLs to
   // test if a URL is bookmarked; it may be NULL during testing.
   bool Init(const FilePath& history_dir, BookmarkService* bookmark_service) {
-    return Init(history_dir, bookmark_service, false);
+    return Init(history_dir, bookmark_service, false, false);
   }
 
   // Triggers the backend to load if it hasn't already, and then returns whether
   // it's finished loading.
   // Note: Virtual needed for mocking.
   virtual bool BackendLoaded();
 
   // Returns true if the backend has finished loading.
   bool backend_loaded() const { return backend_loaded_; }
 
@@ skipping 122 matching lines @@
 
   // Querying ------------------------------------------------------------------
 
   // Callback class that a client can implement to iterate over URLs. The
   // callbacks WILL BE CALLED ON THE BACKGROUND THREAD! Your implementation
   // should handle this appropriately.
   class URLEnumerator {
    public:
     // Indicates that a URL is available. There will be exactly one call for
     // every URL in history.
-    virtual void OnURL(const GURL& url) = 0;
+    virtual void OnURL(const history::URLRow& url_row) = 0;
 
     // Indicates we are done iterating over URLs. Once called, there will be no
     // more callbacks made. This call is guaranteed to occur, even if there are
     // no URLs. If all URLs were iterated, success will be true.
     virtual void OnComplete(bool success) = 0;
 
    protected:
     virtual ~URLEnumerator() {}
   };
 
@@ skipping 114 matching lines @@
       QueryFilteredURLsCallback;
 
   // Request the |result_count| most visited URLs and the chain of
   // redirects leading to each of these URLs. |days_back| is the
   // number of days of history to use. Used by TopSites.
   Handle QueryMostVisitedURLs(int result_count, int days_back,
                               CancelableRequestConsumerBase* consumer,
                               const QueryMostVisitedURLsCallback& callback);
 
   // Request the |result_count| URLs filtered and sorted based on the |filter|.
-  // If |extended_info| is enabled, additional data will be provided in the
-  // results.
+  // If |extended_info| is true, additional data will be provided in the
+  // results. Computing this additional data is expensive, likely to become
+  // more expensive as additional data points are added in future changes, and
+  // not useful in most cases. Set |extended_info| to true only if you
+  // explicitly require the additional data.
   Handle QueryFilteredURLs(
       int result_count,
       const history::VisitFilter& filter,
       bool extended_info,
       CancelableRequestConsumerBase* consumer,
       const QueryFilteredURLsCallback& callback);
 
   // Thumbnails ----------------------------------------------------------------
 
   // Implemented by consumers to get thumbnail data. Called when a request for
@@ skipping 207 matching lines @@
   void StartTopSitesMigration(int backend_id);
 
   // Called by TopSites after the thumbnails were read and it is safe
   // to delete the thumbnails DB.
   void OnTopSitesReady();
 
   // Returns true if this looks like the type of URL we want to add to the
   // history. We filter out some URLs such as JavaScript.
   static bool CanAddURL(const GURL& url);
 
+  // Returns the history backend associated with this service.
+  history::HistoryBackend* get_history_backend_for_testing() {
+    return history_backend_.get();
+  }
+
  protected:
   virtual ~HistoryService();
 
   // These are not currently used, hopefully we can do something in the future
   // to ensure that the most important things happen first.
   enum SchedulePriority {
     PRIORITY_UI,      // The highest priority (must respond to UI events).
     PRIORITY_NORMAL,  // Normal stuff like adding a page.
     PRIORITY_LOW,     // Low priority things like indexing or expiration.
   };
 
  private:
   class BackendDelegate;
 #if defined(OS_ANDROID)
   friend class AndroidHistoryProviderService;
 #endif
   friend class base::RefCountedThreadSafe<HistoryService>;
   friend class BackendDelegate;
+  friend class CacheTestingProfile;
   friend class FaviconService;
   friend class history::HistoryBackend;
   friend class history::HistoryQueryTest;
   friend class HistoryOperation;
   friend class HistoryURLProvider;
   friend class HistoryURLProviderTest;
-  friend class history::InMemoryURLIndexTest;
+  friend class InMemoryURLIndexBaseTest;
   template<typename Info, typename Callback> friend class DownloadRequest;
   friend class PageUsageRequest;
   friend class RedirectRequest;
   friend class TestingProfile;
 
   // Implementation of content::NotificationObserver.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  // Low-level Init().  Same as the public version, but adds a |no_db| parameter
-  // that is only set by unittests which causes the backend to not init its DB.
+  // Low-level Init().  Same as the public version, but adds the |no_db| and
+  // |disable_index_cache| parameters that are only set by unittests.  |no_db|
+  // causes the backend to not init its DB. |disable_index_cache| causes the
+  // InMemoryURLIndex to not create or use its cache database.
   bool Init(const FilePath& history_dir,
             BookmarkService* bookmark_service,
-            bool no_db);
+            bool no_db,
+            bool disable_index_cache);
 
   // Called by the HistoryURLProvider class to schedule an autocomplete, it
   // will be called back on the internal history thread with the history
   // database so it can query. See history_autocomplete.cc for a diagram.
   void ScheduleAutocomplete(HistoryURLProvider* provider,
                             HistoryURLProviderParams* params);
 
   // Broadcasts the given notification. This is called by the backend so that
   // the notification will be broadcast on the main thread.
   //
@@ skipping 248 matching lines @@
   // You MUST communicate with this class ONLY through the thread_'s
   // message_loop().
   //
   // This pointer will be NULL once Cleanup() has been called, meaning no
   // more calls should be made to the history thread.
   scoped_refptr<history::HistoryBackend> history_backend_;
 
   // A cache of the user-typed URLs kept in memory that is used by the
   // autocomplete system. This will be NULL until the database has been created
   // on the background thread.
+  // TODO(mrossetti): Consider changing ownership. See http://crbug.com/138321
   scoped_ptr<history::InMemoryHistoryBackend> in_memory_backend_;
 
   // The profile, may be null when testing.
   Profile* profile_;
 
   // Has the backend finished loading? The backend is loaded once Init has
   // completed.
   bool backend_loaded_;
 
   // The id of the current backend. This is only valid when history_backend_
   // is not NULL.
   int current_backend_id_;
 
   // Cached values from Init(), used whenever we need to reload the backend.
   FilePath history_dir_;
   BookmarkService* bookmark_service_;
   bool no_db_;
 
   // True if needs top site migration.
   bool needs_top_sites_migration_;
 
   // The index used for quick history lookups.
+  // TODO(mrossetti): Move in_memory_url_index out of history_service.
+  // See http://crbug.com/138321
   scoped_ptr<history::InMemoryURLIndex> in_memory_url_index_;
 
   scoped_refptr<ObserverListThreadSafe<history::VisitDatabaseObserver> >
       visit_database_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_H_