Introduce HistoryClient interface

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 <vector>
 
@@ skipping 23 matching lines @@
 #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)
 class AndroidHistoryProviderService;
 #endif
+
 class BookmarkService;
 class GURL;
 class HistoryURLProvider;
 class PageUsageData;
 class PageUsageRequest;
 class Profile;
 struct HistoryURLProviderParams;
 struct ImportedFaviconUsage;
 
 namespace base {
 class FilePath;
 class Thread;
 }
 
 namespace visitedlink {
 class VisitedLinkMaster;
 }
 
 namespace history {
 
 class HistoryBackend;
+class HistoryClient;
 class HistoryDatabase;
 class HistoryDBTask;
 class HistoryQueryTest;
 class InMemoryHistoryBackend;
 class InMemoryURLIndex;
 class InMemoryURLIndexTest;
 class URLDatabase;
 class VisitDatabaseObserver;
 class VisitFilter;
 struct DownloadRow;
 struct HistoryAddPageArgs;
 struct HistoryDetails;
 
 }  // 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 CancelableRequestProvider,
                        public content::NotificationObserver,
                        public syncer::SyncableService,
                        public KeyedService,
                        public visitedlink::VisitedLinkDelegate {
  public:
   // Miscellaneous commonly-used types.
   typedef std::vector<PageUsageData*> PageUsageDataList;
 
-  // Must call Init after construction.
-  explicit HistoryService(Profile* profile);
+  // Must call Init after construction. The |history::HistoryClient| object
+  // must be valid for the whole life time of |HistoryService|.
+  explicit HistoryService(history::HistoryClient* client, Profile* profile);
   // The empty constructor is provided only for testing.
   HistoryService();
 
   virtual ~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 base::FilePath& history_dir, BookmarkService* bookmark_service) {
@@ skipping 449 matching lines @@
                           history::VisitSource visit_source);
 
   // The same as AddPageWithDetails() but takes a vector.
   void AddPagesWithDetails(const history::URLRows& info,
                            history::VisitSource visit_source);
 
   // 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 HistoryClient.
+  history::HistoryClient* history_client() { return history_client_; }
+
   base::WeakPtr<HistoryService> AsWeakPtr();
 
   // syncer::SyncableService implementation.
   virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
       scoped_ptr<syncer::SyncErrorFactory> error_handler) OVERRIDE;
   virtual void StopSyncing(syncer::ModelType type) OVERRIDE;
   virtual syncer::SyncDataList GetAllSyncData(
@@ skipping 437 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 client, may be null when testing. The object should outlive

[blundell, 2014/05/30 12:19:04]

s/should/should otherwise

[sdefresne, 2014/05/30 12:42:15]

Done.

+  // |HistoryService|.
+  history::HistoryClient* history_client_;
+
   // The profile, may be null when testing.
   Profile* profile_;
 
   // 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_;
   BookmarkService* bookmark_service_;
   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::VisitDatabaseObserver> visit_database_observers_;
 
   history::DeleteDirectiveHandler delete_directive_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_