1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_
6 #define CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_
11 #include "base/basictypes.h"
12 #include "base/bind.h"
13 #include "base/callback.h"
14 #include "base/files/file_path.h"
15 #include "base/logging.h"
16 #include "base/memory/ref_counted.h"
17 #include "base/memory/scoped_ptr.h"
18 #include "base/memory/weak_ptr.h"
19 #include "base/observer_list.h"
20 #include "base/strings/string16.h"
21 #include "base/threading/thread_checker.h"
22 #include "base/time/time.h"
23 #include "chrome/browser/common/cancelable_request.h"
24 #include "chrome/browser/favicon/favicon_service.h"
25 #include "chrome/browser/history/delete_directive_handler.h"
26 #include "chrome/browser/history/history_types.h"
27 #include "chrome/browser/history/typed_url_syncable_service.h"
28 #include "chrome/browser/search_engines/template_url_id.h"
29 #include "chrome/common/cancelable_task_tracker.h"
30 #include "chrome/common/ref_counted_util.h"
31 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
32 #include "components/visitedlink/browser/visitedlink_delegate.h"
33 #include "content/public/browser/download_manager_delegate.h"
34 #include "content/public/browser/notification_observer.h"
35 #include "content/public/browser/notification_registrar.h"
36 #include "content/public/common/page_transition_types.h"
37 #include "sql/init_status.h"
38 #include "sync/api/syncable_service.h"
39 #include "ui/base/layout.h"
41 #if defined(OS_ANDROID)
42 #include "chrome/browser/history/android/android_history_provider_service.h"
45 class BookmarkService;
47 class HistoryURLProvider;
49 class PageUsageRequest;
51 struct HistoryURLProviderParams;
58 namespace visitedlink {
59 class VisitedLinkMaster;
65 class HistoryDatabase;
67 class HistoryQueryTest;
68 class InMemoryHistoryBackend;
69 class InMemoryURLIndex;
70 class InMemoryURLIndexTest;
72 class VisitDatabaseObserver;
75 struct HistoryAddPageArgs;
76 struct HistoryDetails;
78 } // namespace history
80 // The history service records page titles, and visit times, as well as
81 // (eventually) information about autocomplete.
83 // This service is thread safe. Each request callback is invoked in the
84 // thread that made the request.
85 class HistoryService : public CancelableRequestProvider,
86 public content::NotificationObserver,
87 public syncer::SyncableService,
88 public BrowserContextKeyedService,
89 public visitedlink::VisitedLinkDelegate {
91 // Miscellaneous commonly-used types.
92 typedef std::vector<PageUsageData*> PageUsageDataList;
94 // Must call Init after construction.
95 explicit HistoryService(Profile* profile);
96 // The empty constructor is provided only for testing.
99 virtual ~HistoryService();
101 // Initializes the history service, returning true on success. On false, do
102 // not call any other functions. The given directory will be used for storing
103 // the history files. The BookmarkService is used when deleting URLs to
104 // test if a URL is bookmarked; it may be NULL during testing.
105 bool Init(const base::FilePath& history_dir, BookmarkService* bookmark_service) {
106 return Init(history_dir, bookmark_service, false);
109 // Triggers the backend to load if it hasn't already, and then returns whether
110 // it's finished loading.
111 // Note: Virtual needed for mocking.
112 virtual bool BackendLoaded();
114 // Returns true if the backend has finished loading.
115 bool backend_loaded() const { return backend_loaded_; }
117 // Unloads the backend without actually shutting down the history service.
118 // This can be used to temporarily reduce the browser process' memory
120 void UnloadBackend();
122 // Called on shutdown, this will tell the history backend to complete and
123 // will release pointers to it. No other functions should be called once
124 // cleanup has happened that may dispatch to the history thread (because it
127 // In practice, this will be called by the service manager (BrowserProcess)
128 // when it is being destroyed. Because that reference is being destroyed, it
129 // should be impossible for anybody else to call the service, even if it is
130 // still in memory (pending requests may be holding a reference to us).
133 // RenderProcessHost pointers are used to scope page IDs (see AddPage). These
134 // objects must tell us when they are being destroyed so that we can clear
135 // out any cached data associated with that scope.
137 // The given pointer will not be dereferenced, it is only used for
138 // identification purposes, hence it is a void*.
139 void NotifyRenderProcessHostDestruction(const void* host);
141 // Triggers the backend to load if it hasn't already, and then returns the
142 // in-memory URL database. The returned pointer MAY BE NULL if the in-memory
143 // database has not been loaded yet. This pointer is owned by the history
144 // system. Callers should not store or cache this value.
146 // TODO(brettw) this should return the InMemoryHistoryBackend.
147 history::URLDatabase* InMemoryDatabase();
149 // Following functions get URL information from in-memory database.
150 // They return false if database is not available (e.g. not loaded yet) or the
151 // URL does not exist.
153 // Reads the number of times the user has typed the given URL.
154 bool GetTypedCountForURL(const GURL& url, int* typed_count);
156 // Reads the last visit time for the given URL.
157 bool GetLastVisitTimeForURL(const GURL& url, base::Time* last_visit);
159 // Reads the number of times this URL has been visited.
160 bool GetVisitCountForURL(const GURL& url, int* visit_count);
162 // Returns a pointer to the TypedUrlSyncableService owned by HistoryBackend.
163 // This method should only be called from the history thread, because the
164 // returned service is intended to be accessed only via the history thread.
165 history::TypedUrlSyncableService* GetTypedUrlSyncableService() const;
167 // Return the quick history index.
168 history::InMemoryURLIndex* InMemoryIndex() const {
169 return in_memory_url_index_.get();
172 // BrowserContextKeyedService:
173 virtual void Shutdown() OVERRIDE;
175 // Navigation ----------------------------------------------------------------
177 // Adds the given canonical URL to history with the given time as the visit
178 // time. Referrer may be the empty string.
180 // The supplied render process host is used to scope the given page ID. Page
181 // IDs are only unique inside a given render process, so we need that to
182 // differentiate them. This pointer should not be dereferenced by the history
185 // The scope/ids can be NULL if there is no meaningful tracking information
186 // that can be performed on the given URL. The 'page_id' should be the ID of
187 // the current session history entry in the given process.
189 // 'redirects' is an array of redirect URLs leading to this page, with the
190 // page itself as the last item (so when there is no redirect, it will have
191 // one entry). If there are no redirects, this array may also be empty for
192 // the convenience of callers.
194 // 'did_replace_entry' is true when the navigation entry for this page has
195 // replaced the existing entry. A non-user initiated redirect causes such
198 // All "Add Page" functions will update the visited link database.
199 void AddPage(const GURL& url,
201 const void* id_scope,
203 const GURL& referrer,
204 const history::RedirectList& redirects,
205 content::PageTransition transition,
206 history::VisitSource visit_source,
207 bool did_replace_entry);
209 // For adding pages to history where no tracking information can be done.
210 void AddPage(const GURL& url,
212 history::VisitSource visit_source);
214 // All AddPage variants end up here.
215 void AddPage(const history::HistoryAddPageArgs& add_page_args);
217 // Adds an entry for the specified url without creating a visit. This should
218 // only be used when bookmarking a page, otherwise the row leaks in the
219 // history db (it never gets cleaned).
220 void AddPageNoVisitForBookmark(const GURL& url, const string16& title);
222 // Sets the title for the given page. The page should be in history. If it
223 // is not, this operation is ignored. This call will not update the full
224 // text index. The last title set when the page is indexed will be the
225 // title in the full text index.
226 void SetPageTitle(const GURL& url, const string16& title);
228 // Updates the history database with a page's ending time stamp information.
229 // The page can be identified by the combination of the pointer to
230 // a RenderProcessHost, the page id and the url.
232 // The given pointer will not be dereferenced, it is only used for
233 // identification purposes, hence it is a void*.
234 void UpdateWithPageEndTime(const void* host,
239 // Indexing ------------------------------------------------------------------
241 // Notifies history of the body text of the given recently-visited URL.
242 // If the URL was not visited "recently enough," the history system may
244 void SetPageContents(const GURL& url, const string16& contents);
246 // Querying ------------------------------------------------------------------
248 // Returns the information about the requested URL. If the URL is found,
249 // success will be true and the information will be in the URLRow parameter.
250 // On success, the visits, if requested, will be sorted by date. If they have
251 // not been requested, the pointer will be valid, but the vector will be
254 // If success is false, neither the row nor the vector will be valid.
255 typedef base::Callback<void(
257 bool, // Success flag, when false, nothing else is valid.
258 const history::URLRow*,
259 history::VisitVector*)> QueryURLCallback;
261 // Queries the basic information about the URL in the history database. If
262 // the caller is interested in the visits (each time the URL is visited),
263 // set |want_visits| to true. If these are not needed, the function will be
264 // faster by setting this to false.
265 Handle QueryURL(const GURL& url,
267 CancelableRequestConsumerBase* consumer,
268 const QueryURLCallback& callback);
270 // Provides the result of a query. See QueryResults in history_types.h.
271 // The common use will be to use QueryResults.Swap to suck the contents of
272 // the results out of the passed in parameter and take ownership of them.
273 typedef base::Callback<void(Handle, history::QueryResults*)>
274 QueryHistoryCallback;
276 // Queries all history with the given options (see QueryOptions in
277 // history_types.h). If non-empty, the full-text database will be queried with
278 // the given |text_query|. If empty, all results matching the given options
281 // This isn't totally hooked up yet, this will query the "new" full text
282 // database (see SetPageContents) which won't generally be set yet.
283 Handle QueryHistory(const string16& text_query,
284 const history::QueryOptions& options,
285 CancelableRequestConsumerBase* consumer,
286 const QueryHistoryCallback& callback);
288 // Called when the results of QueryRedirectsFrom are available.
289 // The given vector will contain a list of all redirects, not counting
290 // the original page. If A redirects to B, the vector will contain only B,
291 // and A will be in 'source_url'.
293 // If there is no such URL in the database or the most recent visit has no
294 // redirect, the vector will be empty. If the history system failed for
295 // some reason, success will additionally be false. If the given page
296 // has redirected to multiple destinations, this will pick a random one.
297 typedef base::Callback<void(Handle,
300 history::RedirectList*)> QueryRedirectsCallback;
302 // Schedules a query for the most recent redirect coming out of the given
303 // URL. See the RedirectQuerySource above, which is guaranteed to be called
304 // if the request is not canceled.
305 Handle QueryRedirectsFrom(const GURL& from_url,
306 CancelableRequestConsumerBase* consumer,
307 const QueryRedirectsCallback& callback);
309 // Schedules a query to get the most recent redirects ending at the given
311 Handle QueryRedirectsTo(const GURL& to_url,
312 CancelableRequestConsumerBase* consumer,
313 const QueryRedirectsCallback& callback);
315 typedef base::Callback<
317 bool, // Were we able to determine the # of visits?
318 int, // Number of visits.
319 base::Time)> // Time of first visit. Only set if bool
320 // is true and int is > 0.
321 GetVisibleVisitCountToHostCallback;
323 // Requests the number of user-visible visits (i.e. no redirects or subframes)
324 // to all urls on the same scheme/host/port as |url|. This is only valid for
325 // HTTP and HTTPS URLs.
326 Handle GetVisibleVisitCountToHost(
328 CancelableRequestConsumerBase* consumer,
329 const GetVisibleVisitCountToHostCallback& callback);
331 // Called when QueryTopURLsAndRedirects completes. The vector contains a list
332 // of the top |result_count| URLs. For each of these URLs, there is an entry
333 // in the map containing redirects from the URL. For example, if we have the
334 // redirect chain A -> B -> C and A is a top visited URL, then A will be in
335 // the vector and "A => {B -> C}" will be in the map.
336 typedef base::Callback<
338 bool, // Did we get the top urls and redirects?
339 std::vector<GURL>*, // List of top URLs.
340 history::RedirectMap*)> // Redirects for top URLs.
341 QueryTopURLsAndRedirectsCallback;
343 // Request the top |result_count| most visited URLs and the chain of redirects
344 // leading to each of these URLs.
345 // TODO(Nik): remove this. Use QueryMostVisitedURLs instead.
346 Handle QueryTopURLsAndRedirects(
348 CancelableRequestConsumerBase* consumer,
349 const QueryTopURLsAndRedirectsCallback& callback);
351 typedef base::Callback<void(Handle, history::MostVisitedURLList)>
352 QueryMostVisitedURLsCallback;
354 typedef base::Callback<void(Handle, const history::FilteredURLList&)>
355 QueryFilteredURLsCallback;
357 // Request the |result_count| most visited URLs and the chain of
358 // redirects leading to each of these URLs. |days_back| is the
359 // number of days of history to use. Used by TopSites.
360 Handle QueryMostVisitedURLs(int result_count, int days_back,
361 CancelableRequestConsumerBase* consumer,
362 const QueryMostVisitedURLsCallback& callback);
364 // Request the |result_count| URLs filtered and sorted based on the |filter|.
365 // If |extended_info| is true, additional data will be provided in the
366 // results. Computing this additional data is expensive, likely to become
367 // more expensive as additional data points are added in future changes, and
368 // not useful in most cases. Set |extended_info| to true only if you
369 // explicitly require the additional data.
370 Handle QueryFilteredURLs(
372 const history::VisitFilter& filter,
374 CancelableRequestConsumerBase* consumer,
375 const QueryFilteredURLsCallback& callback);
377 // Database management operations --------------------------------------------
379 // Delete all the information related to a single url.
380 void DeleteURL(const GURL& url);
382 // Delete all the information related to a list of urls. (Deleting
383 // URLs one by one is slow as it has to flush to disk each time.)
384 void DeleteURLsForTest(const std::vector<GURL>& urls);
386 // Removes all visits in the selected time range (including the start time),
387 // updating the URLs accordingly. This deletes the associated data, including
388 // the full text index. This function also deletes the associated favicons,
389 // if they are no longer referenced. |callback| runs when the expiration is
390 // complete. You may use null Time values to do an unbounded delete in
392 // If |restrict_urls| is not empty, only visits to the URLs in this set are
394 void ExpireHistoryBetween(const std::set<GURL>& restrict_urls,
395 base::Time begin_time,
397 const base::Closure& callback,
398 CancelableTaskTracker* tracker);
400 // Removes all visits to specified URLs in specific time ranges.
401 // This is the equivalent ExpireHistoryBetween() once for each element in the
402 // vector. The fields of |ExpireHistoryArgs| map directly to the arguments of
403 // of ExpireHistoryBetween().
404 void ExpireHistory(const std::vector<history::ExpireHistoryArgs>& expire_list,
405 const base::Closure& callback,
406 CancelableTaskTracker* tracker);
408 // Removes all visits to the given URLs in the specified time range. Calls
409 // ExpireHistoryBetween() to delete local visits, and handles deletion of
410 // synced visits if appropriate.
411 void ExpireLocalAndRemoteHistoryBetween(
412 const std::set<GURL>& restrict_urls,
413 base::Time begin_time,
415 const base::Closure& callback,
416 CancelableTaskTracker* tracker);
418 // Processes the given |delete_directive| and sends it to the
419 // SyncChangeProcessor (if it exists). Returns any error resulting
420 // from sending the delete directive to sync.
421 syncer::SyncError ProcessLocalDeleteDirective(
422 const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive);
424 // Downloads -----------------------------------------------------------------
426 // Implemented by the caller of 'CreateDownload' below, and is called when the
427 // history service has created a new entry for a download in the history db.
428 typedef base::Callback<void(bool)> DownloadCreateCallback;
430 // Begins a history request to create a new row for a download. 'info'
431 // contains all the download's creation state, and 'callback' runs when the
432 // history service request is complete. The callback is called on the thread
433 // that calls CreateDownload().
435 const history::DownloadRow& info,
436 const DownloadCreateCallback& callback);
438 // Responds on the calling thread with the maximum id of all downloads records
439 // in the database plus 1.
440 void GetNextDownloadId(const content::DownloadIdCallback& callback);
442 // Implemented by the caller of 'QueryDownloads' below, and is called when the
443 // history service has retrieved a list of all download state. The call
444 typedef base::Callback<void(
445 scoped_ptr<std::vector<history::DownloadRow> >)>
446 DownloadQueryCallback;
448 // Begins a history request to retrieve the state of all downloads in the
449 // history db. 'callback' runs when the history service request is complete,
450 // at which point 'info' contains an array of history::DownloadRow, one per
451 // download. The callback is called on the thread that calls QueryDownloads().
452 void QueryDownloads(const DownloadQueryCallback& callback);
454 // Called to update the history service about the current state of a download.
455 // This is a 'fire and forget' query, so just pass the relevant state info to
456 // the database with no need for a callback.
457 void UpdateDownload(const history::DownloadRow& data);
459 // Permanently remove some downloads from the history system. This is a 'fire
460 // and forget' operation.
461 void RemoveDownloads(const std::set<uint32>& ids);
463 // Visit Segments ------------------------------------------------------------
465 typedef base::Callback<void(Handle, std::vector<PageUsageData*>*)>
466 SegmentQueryCallback;
468 // Query usage data for all visit segments since the provided time.
470 // The request is performed asynchronously and can be cancelled by using the
473 // The vector provided to the callback and its contents is owned by the
474 // history system. It will be deeply deleted after the callback is invoked.
475 // If you want to preserve any PageUsageData instance, simply remove them
478 // The vector contains a list of PageUsageData. Each PageUsageData ID is set
479 // to the segment ID. The URL and all the other information is set to the page
480 // representing the segment.
481 Handle QuerySegmentUsageSince(CancelableRequestConsumerBase* consumer,
482 const base::Time from_time,
483 int max_result_count,
484 const SegmentQueryCallback& callback);
486 // Increases the amount of time the user actively viewed the url.
487 void IncreaseSegmentDuration(const GURL& url,
489 base::TimeDelta delta);
491 // Queries segments based on active time viewed.
492 Handle QuerySegmentDurationSince(CancelableRequestConsumerBase* consumer,
493 base::Time from_time,
494 int max_result_count,
495 const SegmentQueryCallback& callback);
497 // Keyword search terms -----------------------------------------------------
499 // Sets the search terms for the specified url and keyword. url_id gives the
500 // id of the url, keyword_id the id of the keyword and term the search term.
501 void SetKeywordSearchTermsForURL(const GURL& url,
502 TemplateURLID keyword_id,
503 const string16& term);
505 // Deletes all search terms for the specified keyword.
506 void DeleteAllSearchTermsForKeyword(TemplateURLID keyword_id);
508 typedef base::Callback<
509 void(Handle, std::vector<history::KeywordSearchTermVisit>*)>
510 GetMostRecentKeywordSearchTermsCallback;
512 // Returns up to max_count of the most recent search terms starting with the
513 // specified text. The matching is case insensitive. The results are ordered
514 // in descending order up to |max_count| with the most recent search term
516 Handle GetMostRecentKeywordSearchTerms(
517 TemplateURLID keyword_id,
518 const string16& prefix,
520 CancelableRequestConsumerBase* consumer,
521 const GetMostRecentKeywordSearchTermsCallback& callback);
523 // Deletes any search term corresponding to |url|.
524 void DeleteKeywordSearchTermForURL(const GURL& url);
526 // Bookmarks -----------------------------------------------------------------
528 // Notification that a URL is no longer bookmarked.
529 void URLsNoLongerBookmarked(const std::set<GURL>& urls);
531 // Generic Stuff -------------------------------------------------------------
533 // Schedules a HistoryDBTask for running on the history backend thread. See
534 // HistoryDBTask for details on what this does.
535 virtual void ScheduleDBTask(history::HistoryDBTask* task,
536 CancelableRequestConsumerBase* consumer);
538 // Adds or removes observers for the VisitDatabase.
539 void AddVisitDatabaseObserver(history::VisitDatabaseObserver* observer);
540 void RemoveVisitDatabaseObserver(history::VisitDatabaseObserver* observer);
542 void NotifyVisitDBObserversOnAddVisit(const history::BriefVisitInfo& info);
544 // Testing -------------------------------------------------------------------
546 // Runs |flushed| after bouncing off the history thread.
547 void FlushForTest(const base::Closure& flushed);
549 // Designed for unit tests, this passes the given task on to the history
550 // backend to be called once the history backend has terminated. This allows
551 // callers to know when the history thread is complete and the database files
552 // can be deleted and the next test run. Otherwise, the history thread may
553 // still be running, causing problems in subsequent tests.
555 // There can be only one closing task, so this will override any previously
556 // set task. We will take ownership of the pointer and delete it when done.
557 // The task will be run on the calling thread (this function is threadsafe).
558 void SetOnBackendDestroyTask(const base::Closure& task);
560 // Used for unit testing and potentially importing to get known information
561 // into the database. This assumes the URL doesn't exist in the database
563 // Calling this function many times may be slow because each call will
564 // dispatch to the history thread and will be a separate database
565 // transaction. If this functionality is needed for importing many URLs,
566 // callers should use AddPagesWithDetails() instead.
568 // Note that this routine (and AddPageWithDetails()) always adds a single
569 // visit using the |last_visit| timestamp, and a PageTransition type of LINK,
570 // if |visit_source| != SYNCED.
571 void AddPageWithDetails(const GURL& url,
572 const string16& title,
575 base::Time last_visit,
577 history::VisitSource visit_source);
579 // The same as AddPageWithDetails() but takes a vector.
580 void AddPagesWithDetails(const history::URLRows& info,
581 history::VisitSource visit_source);
583 // Returns true if this looks like the type of URL we want to add to the
584 // history. We filter out some URLs such as JavaScript.
585 static bool CanAddURL(const GURL& url);
587 base::WeakPtr<HistoryService> AsWeakPtr();
589 // syncer::SyncableService implementation.
590 virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
591 syncer::ModelType type,
592 const syncer::SyncDataList& initial_sync_data,
593 scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
594 scoped_ptr<syncer::SyncErrorFactory> error_handler) OVERRIDE;
595 virtual void StopSyncing(syncer::ModelType type) OVERRIDE;
596 virtual syncer::SyncDataList GetAllSyncData(
597 syncer::ModelType type) const OVERRIDE;
598 virtual syncer::SyncError ProcessSyncChanges(
599 const tracked_objects::Location& from_here,
600 const syncer::SyncChangeList& change_list) OVERRIDE;
603 // These are not currently used, hopefully we can do something in the future
604 // to ensure that the most important things happen first.
605 enum SchedulePriority {
606 PRIORITY_UI, // The highest priority (must respond to UI events).
607 PRIORITY_NORMAL, // Normal stuff like adding a page.
608 PRIORITY_LOW, // Low priority things like indexing or expiration.
612 class BackendDelegate;
613 #if defined(OS_ANDROID)
614 friend class AndroidHistoryProviderService;
616 friend class base::RefCountedThreadSafe<HistoryService>;
617 friend class BackendDelegate;
618 friend class FaviconService;
619 friend class history::HistoryBackend;
620 friend class history::HistoryQueryTest;
621 friend class HistoryOperation;
622 friend class HistoryQuickProviderTest;
623 friend class HistoryURLProvider;
624 friend class HistoryURLProviderTest;
625 friend class history::InMemoryURLIndexTest;
626 template<typename Info, typename Callback> friend class DownloadRequest;
627 friend class PageUsageRequest;
628 friend class RedirectRequest;
629 friend class TestingProfile;
631 // Implementation of content::NotificationObserver.
632 virtual void Observe(int type,
633 const content::NotificationSource& source,
634 const content::NotificationDetails& details) OVERRIDE;
636 // Implementation of visitedlink::VisitedLinkDelegate.
637 virtual void RebuildTable(
638 const scoped_refptr<URLEnumerator>& enumerator) OVERRIDE;
640 // Low-level Init(). Same as the public version, but adds a |no_db| parameter
641 // that is only set by unittests which causes the backend to not init its DB.
642 bool Init(const base::FilePath& history_dir,
643 BookmarkService* bookmark_service,
646 // Called by the HistoryURLProvider class to schedule an autocomplete, it
647 // will be called back on the internal history thread with the history
648 // database so it can query. See history_autocomplete.cc for a diagram.
649 void ScheduleAutocomplete(HistoryURLProvider* provider,
650 HistoryURLProviderParams* params);
652 // Broadcasts the given notification. This is called by the backend so that
653 // the notification will be broadcast on the main thread.
655 // Compared to BroadcastNotifications(), this function does not take
656 // ownership of |details|.
657 void BroadcastNotificationsHelper(int type,
658 history::HistoryDetails* details);
660 // Initializes the backend.
661 void LoadBackendIfNecessary();
663 // Notification from the backend that it has finished loading. Sends
664 // notification (NOTIFY_HISTORY_LOADED) and sets backend_loaded_ to true.
665 void OnDBLoaded(int backend_id);
667 // Helper function for getting URL information.
668 // Reads a URLRow from in-memory database. Returns false if database is not
669 // available or the URL does not exist.
670 bool GetRowForURL(const GURL& url, history::URLRow* url_row);
672 // Favicon -------------------------------------------------------------------
674 // These favicon methods are exposed to the FaviconService. Instead of calling
675 // these methods directly you should call the respective method on the
678 // Used by FaviconService to get the favicon bitmaps from the history backend
679 // which most closely match |desired_size_in_dip| x |desired_size_in_dip| and
680 // |desired_scale_factors| for |icon_types|. If |desired_size_in_dip| is 0,
681 // the largest favicon bitmap for |icon_types| is returned. The returned
682 // FaviconBitmapResults will have at most one result for each of
683 // |desired_scale_factors|. If a favicon bitmap is determined to be the best
684 // candidate for multiple scale factors there will be less results.
685 // If |icon_types| has several types, results for only a single type will be
686 // returned in the priority of TOUCH_PRECOMPOSED_ICON, TOUCH_ICON, and
688 CancelableTaskTracker::TaskId GetFavicons(
689 const std::vector<GURL>& icon_urls,
691 int desired_size_in_dip,
692 const std::vector<ui::ScaleFactor>& desired_scale_factors,
693 const FaviconService::FaviconResultsCallback& callback,
694 CancelableTaskTracker* tracker);
696 // Used by the FaviconService to get favicons mapped to |page_url| for
697 // |icon_types| which most closely match |desired_size_in_dip| and
698 // |desired_scale_factors|. If |desired_size_in_dip| is 0, the largest favicon
699 // bitmap for |icon_types| is returned. The returned FaviconBitmapResults will
700 // have at most one result for each of |desired_scale_factors|. If a favicon
701 // bitmap is determined to be the best candidate for multiple scale factors
702 // there will be less results. If |icon_types| has several types, results for
703 // only a single type will be returned in the priority of
704 // TOUCH_PRECOMPOSED_ICON, TOUCH_ICON, and FAVICON.
705 CancelableTaskTracker::TaskId GetFaviconsForURL(
706 const GURL& page_url,
708 int desired_size_in_dip,
709 const std::vector<ui::ScaleFactor>& desired_scale_factors,
710 const FaviconService::FaviconResultsCallback& callback,
711 CancelableTaskTracker* tracker);
713 // Used by FaviconService to find the first favicon bitmap whose width and
714 // height are greater than that of |minimum_size_in_pixels|. This searches
715 // for icons by IconType. Each element of |icon_types| is a bitmask of
716 // IconTypes indicating the types to search for.
717 // If the largest icon of |icon_types[0]| is not larger than
718 // |minimum_size_in_pixel|, the next icon types of
719 // |icon_types| will be searched and so on.
720 // If no icon is larger than |minimum_size_in_pixel|, the largest one of all
721 // icon types in |icon_types| is returned.
722 // This feature is especially useful when some types of icon is perfered as
723 // long as its size is larger than a specific value.
724 CancelableTaskTracker::TaskId GetLargestFaviconForURL(
725 const GURL& page_url,
726 const std::vector<int>& icon_types,
727 int minimum_size_in_pixels,
728 const FaviconService::FaviconRawCallback& callback,
729 CancelableTaskTracker* tracker);
731 // Used by the FaviconService to get the favicon bitmap which most closely
732 // matches |desired_size_in_dip| and |desired_scale_factor| from the favicon
733 // with |favicon_id| from the history backend. If |desired_size_in_dip| is 0,
734 // the largest favicon bitmap for |favicon_id| is returned.
735 CancelableTaskTracker::TaskId GetFaviconForID(
736 chrome::FaviconID favicon_id,
737 int desired_size_in_dip,
738 ui::ScaleFactor desired_scale_factor,
739 const FaviconService::FaviconResultsCallback& callback,
740 CancelableTaskTracker* tracker);
742 // Used by the FaviconService to replace the favicon mappings to |page_url|
743 // for |icon_types| on the history backend.
744 // Sample |icon_urls|:
745 // { ICON_URL1 -> TOUCH_ICON, known to the database,
746 // ICON_URL2 -> TOUCH_ICON, not known to the database,
747 // ICON_URL3 -> TOUCH_PRECOMPOSED_ICON, known to the database }
748 // The new mappings are computed from |icon_urls| with these rules:
749 // 1) Any urls in |icon_urls| which are not already known to the database are
751 // Sample new mappings to |page_url|: { ICON_URL1, ICON_URL3 }
752 // 2) If |icon_types| has multiple types, the mappings are only set for the
753 // largest icon type.
754 // Sample new mappings to |page_url|: { ICON_URL3 }
755 // |icon_types| can only have multiple IconTypes if
756 // |icon_types| == TOUCH_ICON | TOUCH_PRECOMPOSED_ICON.
757 // The favicon bitmaps which most closely match |desired_size_in_dip|
758 // and |desired_scale_factors| from the favicons which were just mapped
759 // to |page_url| are returned. If |desired_size_in_dip| is 0, the
760 // largest favicon bitmap is returned.
761 CancelableTaskTracker::TaskId UpdateFaviconMappingsAndFetch(
762 const GURL& page_url,
763 const std::vector<GURL>& icon_urls,
765 int desired_size_in_dip,
766 const std::vector<ui::ScaleFactor>& desired_scale_factors,
767 const FaviconService::FaviconResultsCallback& callback,
768 CancelableTaskTracker* tracker);
770 // Used by FaviconService to set a favicon for |page_url| and |icon_url| with
773 // |page_url|: www.google.com
774 // 2 favicons in history for |page_url|:
775 // www.google.com/a.ico 16x16
776 // www.google.com/b.ico 32x32
777 // MergeFavicon(|page_url|, www.google.com/a.ico, ..., ..., 16x16)
779 // Merging occurs in the following manner:
780 // 1) |page_url| is set to map to only to |icon_url|. In order to not lose
781 // data, favicon bitmaps mapped to |page_url| but not to |icon_url| are
782 // copied to the favicon at |icon_url|.
783 // For the example above, |page_url| will only be mapped to a.ico.
784 // The 32x32 favicon bitmap at b.ico is copied to a.ico
785 // 2) |bitmap_data| is added to the favicon at |icon_url|, overwriting any
786 // favicon bitmaps of |pixel_size|.
787 // For the example above, |bitmap_data| overwrites the 16x16 favicon
789 // TODO(pkotwicz): Remove once no longer required by sync.
790 void MergeFavicon(const GURL& page_url,
791 const GURL& icon_url,
792 chrome::IconType icon_type,
793 scoped_refptr<base::RefCountedMemory> bitmap_data,
794 const gfx::Size& pixel_size);
796 // Used by the FaviconService to set the favicons for a page on the history
798 // |favicon_bitmap_data| replaces all the favicon bitmaps mapped to
800 // |expired| and |icon_type| fields in FaviconBitmapData are ignored.
801 // Use MergeFavicon() if |favicon_bitmap_data| is incomplete, and favicon
802 // bitmaps in the database should be preserved if possible. For instance,
803 // favicon bitmaps from sync are 1x only. MergeFavicon() is used to avoid
804 // deleting the 2x favicon bitmap if it is present in the history backend.
805 // See HistoryBackend::ValidateSetFaviconsParams() for more details on the
806 // criteria for |favicon_bitmap_data| to be valid.
808 const GURL& page_url,
809 chrome::IconType icon_type,
810 const std::vector<chrome::FaviconBitmapData>& favicon_bitmap_data);
812 // Used by the FaviconService to mark the favicon for the page as being out
814 void SetFaviconsOutOfDateForPage(const GURL& page_url);
816 // Used by the FaviconService to clone favicons from one page to another,
817 // provided that other page does not already have favicons.
818 void CloneFavicons(const GURL& old_page_url, const GURL& new_page_url);
820 // Used by the FaviconService for importing many favicons for many pages at
821 // once. The pages must exist, any favicon sets for unknown pages will be
822 // discarded. Existing favicons will not be overwritten.
823 void SetImportedFavicons(
824 const std::vector<ImportedFaviconUsage>& favicon_usage);
826 // Sets the in-memory URL database. This is called by the backend once the
827 // database is loaded to make it available.
828 void SetInMemoryBackend(
830 scoped_ptr<history::InMemoryHistoryBackend> mem_backend);
832 // Called by our BackendDelegate when there is a problem reading the database.
833 void NotifyProfileError(int backend_id, sql::InitStatus init_status);
835 // Call to schedule a given task for running on the history thread with the
836 // specified priority. The task will have ownership taken.
837 void ScheduleTask(SchedulePriority priority, const base::Closure& task);
839 // Schedule ------------------------------------------------------------------
841 // Functions for scheduling operations on the history thread that have a
842 // handle and may be cancelable. For fire-and-forget operations, see
843 // ScheduleAndForget below.
845 template<typename BackendFunc, class RequestType>
846 Handle Schedule(SchedulePriority priority,
847 BackendFunc func, // Function to call on the HistoryBackend.
848 CancelableRequestConsumerBase* consumer,
849 RequestType* request) {
850 DCHECK(thread_) << "History service being called after cleanup";
851 DCHECK(thread_checker_.CalledOnValidThread());
852 LoadBackendIfNecessary();
854 AddRequest(request, consumer);
855 ScheduleTask(priority,
856 base::Bind(func, history_backend_.get(),
857 scoped_refptr<RequestType>(request)));
858 return request->handle();
861 template<typename BackendFunc, class RequestType, typename ArgA>
862 Handle Schedule(SchedulePriority priority,
863 BackendFunc func, // Function to call on the HistoryBackend.
864 CancelableRequestConsumerBase* consumer,
865 RequestType* request,
867 DCHECK(thread_) << "History service being called after cleanup";
868 DCHECK(thread_checker_.CalledOnValidThread());
869 LoadBackendIfNecessary();
871 AddRequest(request, consumer);
872 ScheduleTask(priority,
873 base::Bind(func, history_backend_.get(),
874 scoped_refptr<RequestType>(request), a));
875 return request->handle();
878 template<typename BackendFunc,
879 class RequestType, // Descendant of CancelableRequestBase.
882 Handle Schedule(SchedulePriority priority,
883 BackendFunc func, // Function to call on the HistoryBackend.
884 CancelableRequestConsumerBase* consumer,
885 RequestType* request,
888 DCHECK(thread_) << "History service being called after cleanup";
889 DCHECK(thread_checker_.CalledOnValidThread());
890 LoadBackendIfNecessary();
892 AddRequest(request, consumer);
893 ScheduleTask(priority,
894 base::Bind(func, history_backend_.get(),
895 scoped_refptr<RequestType>(request), a, b));
896 return request->handle();
899 template<typename BackendFunc,
900 class RequestType, // Descendant of CancelableRequestBase.
904 Handle Schedule(SchedulePriority priority,
905 BackendFunc func, // Function to call on the HistoryBackend.
906 CancelableRequestConsumerBase* consumer,
907 RequestType* request,
911 DCHECK(thread_) << "History service being called after cleanup";
912 DCHECK(thread_checker_.CalledOnValidThread());
913 LoadBackendIfNecessary();
915 AddRequest(request, consumer);
916 ScheduleTask(priority,
917 base::Bind(func, history_backend_.get(),
918 scoped_refptr<RequestType>(request), a, b, c));
919 return request->handle();
922 template<typename BackendFunc,
923 class RequestType, // Descendant of CancelableRequestBase.
928 Handle Schedule(SchedulePriority priority,
929 BackendFunc func, // Function to call on the HistoryBackend.
930 CancelableRequestConsumerBase* consumer,
931 RequestType* request,
936 DCHECK(thread_) << "History service being called after cleanup";
937 DCHECK(thread_checker_.CalledOnValidThread());
938 LoadBackendIfNecessary();
940 AddRequest(request, consumer);
941 ScheduleTask(priority,
942 base::Bind(func, history_backend_.get(),
943 scoped_refptr<RequestType>(request), a, b, c, d));
944 return request->handle();
947 // ScheduleAndForget ---------------------------------------------------------
949 // Functions for scheduling operations on the history thread that do not need
950 // any callbacks and are not cancelable.
952 template<typename BackendFunc>
953 void ScheduleAndForget(SchedulePriority priority,
954 BackendFunc func) { // Function to call on backend.
955 DCHECK(thread_) << "History service being called after cleanup";
956 DCHECK(thread_checker_.CalledOnValidThread());
957 LoadBackendIfNecessary();
958 ScheduleTask(priority, base::Bind(func, history_backend_.get()));
961 template<typename BackendFunc, typename ArgA>
962 void ScheduleAndForget(SchedulePriority priority,
963 BackendFunc func, // Function to call on backend.
965 DCHECK(thread_) << "History service being called after cleanup";
966 DCHECK(thread_checker_.CalledOnValidThread());
967 LoadBackendIfNecessary();
968 ScheduleTask(priority, base::Bind(func, history_backend_.get(), a));
971 template<typename BackendFunc, typename ArgA, typename ArgB>
972 void ScheduleAndForget(SchedulePriority priority,
973 BackendFunc func, // Function to call on backend.
976 DCHECK(thread_) << "History service being called after cleanup";
977 DCHECK(thread_checker_.CalledOnValidThread());
978 LoadBackendIfNecessary();
979 ScheduleTask(priority, base::Bind(func, history_backend_.get(), a, b));
982 template<typename BackendFunc, typename ArgA, typename ArgB, typename ArgC>
983 void ScheduleAndForget(SchedulePriority priority,
984 BackendFunc func, // Function to call on backend.
988 DCHECK(thread_) << "History service being called after cleanup";
989 DCHECK(thread_checker_.CalledOnValidThread());
990 LoadBackendIfNecessary();
991 ScheduleTask(priority, base::Bind(func, history_backend_.get(), a, b, c));
994 template<typename BackendFunc,
999 void ScheduleAndForget(SchedulePriority priority,
1000 BackendFunc func, // Function to call on backend.
1005 DCHECK(thread_) << "History service being called after cleanup";
1006 DCHECK(thread_checker_.CalledOnValidThread());
1007 LoadBackendIfNecessary();
1008 ScheduleTask(priority, base::Bind(func, history_backend_.get(),
1012 template<typename BackendFunc,
1018 void ScheduleAndForget(SchedulePriority priority,
1019 BackendFunc func, // Function to call on backend.
1025 DCHECK(thread_) << "History service being called after cleanup";
1026 DCHECK(thread_checker_.CalledOnValidThread());
1027 LoadBackendIfNecessary();
1028 ScheduleTask(priority, base::Bind(func, history_backend_.get(),
1032 // All vended weak pointers are invalidated in Cleanup().
1033 base::WeakPtrFactory<HistoryService> weak_ptr_factory_;
1035 base::ThreadChecker thread_checker_;
1037 content::NotificationRegistrar registrar_;
1039 // Some void primitives require some internal processing in the main thread
1040 // when done. We use this internal consumer for this purpose.
1041 CancelableRequestConsumer internal_consumer_;
1043 // The thread used by the history service to run complicated operations.
1044 // |thread_| is NULL once |Cleanup| is NULL.
1045 base::Thread* thread_;
1047 // This class has most of the implementation and runs on the 'thread_'.
1048 // You MUST communicate with this class ONLY through the thread_'s
1051 // This pointer will be NULL once Cleanup() has been called, meaning no
1052 // more calls should be made to the history thread.
1053 scoped_refptr<history::HistoryBackend> history_backend_;
1055 // A cache of the user-typed URLs kept in memory that is used by the
1056 // autocomplete system. This will be NULL until the database has been created
1057 // on the background thread.
1058 // TODO(mrossetti): Consider changing ownership. See http://crbug.com/138321
1059 scoped_ptr<history::InMemoryHistoryBackend> in_memory_backend_;
1061 // The profile, may be null when testing.
1064 // Used for propagating link highlighting data across renderers. May be null
1066 scoped_ptr<visitedlink::VisitedLinkMaster> visitedlink_master_;
1068 // Has the backend finished loading? The backend is loaded once Init has
1070 bool backend_loaded_;
1072 // The id of the current backend. This is only valid when history_backend_
1074 int current_backend_id_;
1076 // Cached values from Init(), used whenever we need to reload the backend.
1077 base::FilePath history_dir_;
1078 BookmarkService* bookmark_service_;
1081 // The index used for quick history lookups.
1082 // TODO(mrossetti): Move in_memory_url_index out of history_service.
1083 // See http://crbug.com/138321
1084 scoped_ptr<history::InMemoryURLIndex> in_memory_url_index_;
1086 ObserverList<history::VisitDatabaseObserver> visit_database_observers_;
1088 history::DeleteDirectiveHandler delete_directive_handler_;
1090 DISALLOW_COPY_AND_ASSIGN(HistoryService);
1093 #endif // CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_