Remove VisitedLink dependency on rest of chrome

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>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "base/time.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/common/cancelable_request.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/search_engines/template_url_id.h"
+#include "chrome/browser/visitedlink/visitedlink_delegate.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/ref_counted_util.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/common/page_transition_types.h"
 #include "sql/init_status.h"
 #include "sync/api/syncable_service.h"
 #include "ui/base/layout.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/history/android/android_history_provider_service.h"
 #endif
 
 class BookmarkService;
 class FilePath;
 class GURL;
 class HistoryURLProvider;
 class PageUsageData;
 class PageUsageRequest;
 class Profile;
+class VisitedLinkMaster;
 struct HistoryURLProviderParams;
 
 namespace base {
 class Thread;
 }
 
 
 namespace history {
 
 class HistoryBackend;
@@ skipping 42 matching lines @@
 };
 
 // The history service records page titles, and visit times, as well as
 // (eventually) information about autocomplete.
 //
 // This service is thread safe. Each request callback is invoked in the
 // thread that made the request.
 class HistoryService : public CancelableRequestProvider,
                        public content::NotificationObserver,
                        public syncer::SyncableService,
-                       public ProfileKeyedService {
+                       public ProfileKeyedService,
+                       public VisitedLinkDelegate {
  public:
   // Miscellaneous commonly-used types.
   typedef std::vector<PageUsageData*> PageUsageDataList;
 
   // Must call Init after construction.
   explicit HistoryService(Profile* profile);
   // The empty constructor is provided only for testing.
   HistoryService();
 
   virtual ~HistoryService();
@@ skipping 133 matching lines @@
 
   // Indexing ------------------------------------------------------------------
 
   // Notifies history of the body text of the given recently-visited URL.
   // If the URL was not visited "recently enough," the history system may
   // discard it.
   void SetPageContents(const GURL& url, const string16& contents);
 
   // 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 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() {}
-  };
-
-  // Enumerate all URLs in history. The given iterator will be owned by the
-  // caller, so the caller should ensure it exists until OnComplete is called.
-  // You should not generally use this since it will be slow to slurp all URLs
-  // in from the database. It is designed for rebuilding the visited link
-  // database from history.
-  void IterateURLs(URLEnumerator* iterator);
-
   // Returns the information about the requested URL. If the URL is found,
   // success will be true and the information will be in the URLRow parameter.
   // On success, the visits, if requested, will be sorted by date. If they have
   // not been requested, the pointer will be valid, but the vector will be
   // empty.
   //
   // If success is false, neither the row nor the vector will be valid.
   typedef base::Callback<void(
       Handle,
       bool,  // Success flag, when false, nothing else is valid.
@@ skipping 367 matching lines @@
   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;
 
+  // Implementation of VisitedLinkDelegate.
+  virtual bool IsEquivalentContext(content::BrowserContext* context1,

[Jói, 2012/12/19 14:07:20]

nit: I know I suggested this name, but now that I see it, it's more like a
binary operator so perhaps should call it AreEquivalentContexts?

[boliu, 2012/12/29 01:48:12]

Done.

+                                   content::BrowserContext* context2) OVERRIDE;
+  virtual void RebuildTable(
+      VisitedLinkDelegate::URLEnumerator* enumerator) 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.
   bool Init(const FilePath& history_dir,
             BookmarkService* bookmark_service,
             bool no_db);
 
   // 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,
@@ skipping 401 matching lines @@
 
   // 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_;
 
+  // This is null in tests.
+  scoped_ptr<VisitedLinkMaster> visitedlink_master_;
+
   // 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_;
 
   ObserverList<history::VisitDatabaseObserver> visit_database_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_H_