Remove dependency of HistoryService on WebHistoryServiceFactory

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 21 matching lines @@
 #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;
+struct ImportedFaviconUsage;
 class PageUsageData;
 class PageUsageRequest;
 class Profile;
-struct ImportedFaviconUsage;
 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 HistoryDBTask;
 class HistoryQueryTest;
 class HistoryServiceObserver;
 class HistoryTest;
 class InMemoryHistoryBackend;
 class InMemoryURLIndex;
 class InMemoryURLIndexTest;
+struct KeywordSearchTermVisit;
 class URLDatabase;
 class VisitFilter;
-struct DownloadRow;
-struct HistoryAddPageArgs;
-struct KeywordSearchTermVisit;
+class WebHistoryService;
+
+void ExpireLocalAndRemoteHistoryBetween(HistoryService* local_history,

[droger, 2015/02/05 16:16:13]

This looks like a mistake, the function is also declared in history_util.

+                                        WebHistoryService* web_history,
+                                        const std::set<GURL>& restrict_urls,
+                                        base::Time begin_time,
+                                        base::Time end_time,
+                                        const base::Closure& callback,
+                                        base::CancelableTaskTracker* tracker);
 
 }  // 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,
@@ skipping 259 matching lines @@
                             base::CancelableTaskTracker* tracker);
 
   // Removes all visits to specified URLs in specific time ranges.
   // This is the equivalent ExpireHistoryBetween() once for each element in the
   // vector. The fields of |ExpireHistoryArgs| map directly to the arguments of
   // of ExpireHistoryBetween().
   void ExpireHistory(const std::vector<history::ExpireHistoryArgs>& expire_list,
                      const base::Closure& callback,
                      base::CancelableTaskTracker* tracker);
 
-  // Removes all visits to the given URLs in the specified time range. Calls
-  // ExpireHistoryBetween() to delete local visits, and handles deletion of
-  // synced visits if appropriate.
-  void ExpireLocalAndRemoteHistoryBetween(const std::set<GURL>& restrict_urls,
-                                          base::Time begin_time,
-                                          base::Time end_time,
-                                          const base::Closure& callback,
-                                          base::CancelableTaskTracker* tracker);
-
   // Processes the given |delete_directive| and sends it to the
   // SyncChangeProcessor (if it exists).  Returns any error resulting
   // from sending the delete directive to sync.
   syncer::SyncError ProcessLocalDeleteDirective(
       const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive);
 
   // Downloads -----------------------------------------------------------------
 
   // Implemented by the caller of 'CreateDownload' below, and is called when the
   // history service has created a new entry for a download in the history db.
@@ skipping 167 matching lines @@
   friend class history::HistoryTest;
   friend class HistoryURLProvider;
   friend class HistoryURLProviderTest;
   friend class history::InMemoryURLIndexTest;
   template<typename Info, typename Callback> friend class DownloadRequest;
   friend class PageUsageRequest;
   friend class RedirectRequest;
   friend class SyncBookmarkDataTypeControllerTest;
   friend class TestingProfile;
 
+  friend void history::ExpireLocalAndRemoteHistoryBetween(
+      HistoryService* local_history,
+      history::WebHistoryService* web_history,
+      const std::set<GURL>& restrict_urls,
+      base::Time begin_time,
+      base::Time end_time,
+      const base::Closure& callback,
+      base::CancelableTaskTracker* tracker);
+
   // 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).
   //
   // 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();
@@ skipping 249 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 history client, may be null when testing. The object should otherwise
   // outlive |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_;
@@ skipping 10 matching lines @@
 
   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_