Remove dependency on visitedlink from history

chrome/browser/history/history_service.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_SERVICE_H_
 #define CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 11 matching lines @@
 #include "base/strings/string16.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/delete_directive_handler.h"
 #include "chrome/browser/history/typed_url_syncable_service.h"
 #include "components/favicon_base/favicon_callback.h"
 #include "components/favicon_base/favicon_usage_data.h"
 #include "components/history/core/browser/keyword_id.h"
 #include "components/keyed_service/core/keyed_service.h"
-#include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "sql/init_status.h"
 #include "sync/api/syncable_service.h"
 #include "ui/base/page_transition_types.h"
 
 #if defined(OS_ANDROID)
 class AndroidHistoryProviderService;
 #endif
 
 class GURL;
-class HistoryService;
 class PageUsageRequest;
-class Profile;
 class SkBitmap;
 
 namespace base {
 class FilePath;
 class Thread;
 }
 
-namespace visitedlink {
-class VisitedLinkMaster;
-}
-
 namespace history {
 
 struct DownloadRow;
 struct HistoryAddPageArgs;
 class HistoryBackend;
 class HistoryClient;
 class HistoryDBTask;
 class HistoryDatabase;
 struct HistoryDatabaseParams;
 class HistoryQueryTest;
 class HistoryServiceObserver;
 class HistoryTest;
 class InMemoryHistoryBackend;
 class InMemoryURLIndex;
 class InMemoryURLIndexTest;
 struct KeywordSearchTermVisit;
 class PageUsageData;
 class URLDatabase;
+class VisitDelegate;
 class VisitFilter;
 class WebHistoryService;
 
 }  // namespace history
 
 // 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 syncer::SyncableService,
-                       public KeyedService,
-                       public visitedlink::VisitedLinkDelegate {
+class HistoryService : public syncer::SyncableService, public KeyedService {
  public:
   // Miscellaneous commonly-used types.
   typedef std::vector<history::PageUsageData*> PageUsageDataList;
 
-  // Must call Init after construction. The |history::HistoryClient| object
-  // must be valid for the whole lifetime of |HistoryService|.
-  HistoryService(history::HistoryClient* client, Profile* profile);
-  // The empty constructor is provided only for testing.
+  // Must call Init after construction. The empty constructor provided only for
+  // unit tests. When using the full constructor, |history_client| and |profile|
+  // should only be null during testing, while |visit_delegate| may be null if
+  // the embedder use another way to track visited links.
   HistoryService();
-
+  HistoryService(history::HistoryClient* history_client,
+                 scoped_ptr<history::VisitDelegate> visit_delegate);
   ~HistoryService() override;
 
   // 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. |languages| is a comma-separated list of languages to
   // use when interpreting URLs, it must not be empty (except during testing).
   bool Init(const std::string& languages,
             const history::HistoryDatabaseParams& history_database_params) {
     return Init(false, languages, history_database_params);
   }
 
   // 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_; }
 
   // Context ids are used to scope page IDs (see AddPage). These contexts
   // must tell us when they are being invalidated so that we can clear
   // out any cached data associated with that context.
   void ClearCachedDataForContextID(history::ContextID context_id);
 
   // Triggers the backend to load if it hasn't already, and then returns the
-  // in-memory URL database. The returned pointer MAY BE NULL if the in-memory
+  // in-memory URL database. The returned pointer may be null if the in-memory
   // database has not been loaded yet. This pointer is owned by the history
   // system. Callers should not store or cache this value.
   //
   // TODO(brettw) this should return the InMemoryHistoryBackend.
   history::URLDatabase* InMemoryDatabase();
 
   // Following functions get URL information from in-memory database.
   // They return false if database is not available (e.g. not loaded yet) or the
   // URL does not exist.
 
@@ skipping 21 matching lines @@
 
   // Navigation ----------------------------------------------------------------
 
   // Adds the given canonical URL to history with the given time as the visit
   // time. Referrer may be the empty string.
   //
   // The supplied context id is used to scope the given page ID. Page IDs
   // are only unique inside a given context, so we need that to differentiate
   // them.
   //
-  // The context/page ids can be NULL if there is no meaningful tracking
+  // The context/page ids can be null if there is no meaningful tracking
   // information that can be performed on the given URL. The 'nav_entry_id'
   // should be the unique ID of the current navigation entry in the given
   // process.
   //
   // 'redirects' is an array of redirect URLs leading to this page, with the
   // page itself as the last item (so when there is no redirect, it will have
   // one entry). If there are no redirects, this array may also be empty for
   // the convenience of callers.
   //
   // 'did_replace_entry' is true when the navigation entry for this page has
@@ skipping 211 matching lines @@
   // Implemented by the caller of 'GetNextDownloadId' below, and is called with
   // the maximum id of all downloads records in the database plus 1.
   typedef base::Callback<void(uint32)> DownloadIdCallback;
 
   // Responds on the calling thread with the maximum id of all downloads records
   // in the database plus 1.
   void GetNextDownloadId(const DownloadIdCallback& callback);
 
   // Implemented by the caller of 'QueryDownloads' below, and is called when the
   // history service has retrieved a list of all download state. The call
-  typedef base::Callback<void(
-      scoped_ptr<std::vector<history::DownloadRow> >)>
-          DownloadQueryCallback;
+  typedef base::Callback<void(scoped_ptr<std::vector<history::DownloadRow>>)>
+      DownloadQueryCallback;
 
   // Begins a history request to retrieve the state of all downloads in the
   // history db. 'callback' runs when the history service request is complete,
   // at which point 'info' contains an array of history::DownloadRow, one per
   // download. The callback is called on the thread that calls QueryDownloads().
   void QueryDownloads(const DownloadQueryCallback& callback);
 
   // Called to update the history service about the current state of a download.
   // This is a 'fire and forget' query, so just pass the relevant state info to
   // the database with no need for a callback.
@@ skipping 134 matching lines @@
   friend class history::InMemoryURLIndexTest;
   template<typename Info, typename Callback> friend class DownloadRequest;
   friend class PageUsageRequest;
   friend class RedirectRequest;
   friend class SyncBookmarkDataTypeControllerTest;
   friend class TestingProfile;
 
   // Called on shutdown, this will tell the history backend to complete and
   // will release pointers to it. No other functions should be called once
   // cleanup has happened that may dispatch to the history thread (because it
-  // will be NULL).
+  // will be null).
   //
   // In practice, this will be called by the service manager (BrowserProcess)
   // when it is being destroyed. Because that reference is being destroyed, it
   // should be impossible for anybody else to call the service, even if it is
   // still in memory (pending requests may be holding a reference to us).
   void Cleanup();
 
-  // Implementation of visitedlink::VisitedLinkDelegate.
-  void RebuildTable(const scoped_refptr<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(bool no_db,
             const std::string& languages,
             const history::HistoryDatabaseParams& history_database_params);
 
   // 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(const base::Callback<
@@ skipping 231 matching lines @@
   // 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 history service will inform its VisitDelegate of URLs recorded and
+  // removed from the history database. This may be null during testing.
+  scoped_ptr<history::VisitDelegate> visit_delegate_;
+
   // The history client, may be null when testing. The object should otherwise
   // outlive |HistoryService|.
   history::HistoryClient* history_client_;
 
-  // Used for propagating link highlighting data across renderers. May be null
-  // in tests.
-  scoped_ptr<visitedlink::VisitedLinkMaster> visitedlink_master_;
-
   // Has the backend finished loading? The backend is loaded once Init has
   // completed.
   bool backend_loaded_;
 
   // Cached values from Init(), used whenever we need to reload the backend.
   base::FilePath history_dir_;
   bool no_db_;
 
   // 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::HistoryServiceObserver> observers_;
   base::CallbackList<void(const std::set<GURL>&)>
       favicon_changed_callback_list_;
 
   history::DeleteDirectiveHandler delete_directive_handler_;
 
   // All vended weak pointers are invalidated in Cleanup().
   base::WeakPtrFactory<HistoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_