// Copyright (c) 2011 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.
// The history system runs on a background thread so that potentially slow
// database operations don't delay the browser. This backend processing is
// represented by HistoryBackend. The HistoryService's job is to dispatch to
// that thread.
//
// Main thread History thread
// ----------- --------------
// HistoryService <----------------> HistoryBackend
// -> HistoryDatabase
// -> SQLite connection to History
// -> ArchivedDatabase
// -> SQLite connection to Archived History
// -> TextDatabaseManager
// -> SQLite connection to one month's data
// -> SQLite connection to one month's data
// ...
// -> ThumbnailDatabase
// -> SQLite connection to Thumbnails
// (and favicons)
#include "chrome/browser/history/history.h"
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/message_loop.h"
#include "base/path_service.h"
#include "base/string_util.h"
#include "base/task.h"
#include "chrome/browser/autocomplete/history_url_provider.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/history/download_create_info.h"
#include "chrome/browser/history/history_backend.h"
#include "chrome/browser/history/history_notifications.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/browser/history/in_memory_database.h"
#include "chrome/browser/history/in_memory_history_backend.h"
#include "chrome/browser/history/top_sites.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/profile_error_dialog.h"
#include "chrome/browser/visitedlink/visitedlink_master.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/thumbnail_score.h"
#include "chrome/common/url_constants.h"
#include "content/browser/browser_thread.h"
#include "content/common/notification_service.h"
#include "grit/chromium_strings.h"
#include "grit/generated_resources.h"
#include "third_party/skia/include/core/SkBitmap.h"
using base::Time;
using history::HistoryBackend;
namespace {
static const char* kHistoryThreadName = "Chrome_HistoryThread";
} // namespace
// Sends messages from the backend to us on the main thread. This must be a
// separate class from the history service so that it can hold a reference to
// the history service (otherwise we would have to manually AddRef and
// Release when the Backend has a reference to us).
class HistoryService::BackendDelegate : public HistoryBackend::Delegate {
public:
explicit BackendDelegate(HistoryService* history_service)
: history_service_(history_service),
message_loop_(MessageLoop::current()) {
}
virtual void NotifyProfileError(sql::InitStatus init_status) OVERRIDE {
// Send to the history service on the main thread.
message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
&HistoryService::NotifyProfileError, init_status));
}
virtual void SetInMemoryBackend(
history::InMemoryHistoryBackend* backend) OVERRIDE {
// Send the backend to the history service on the main thread.
message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
&HistoryService::SetInMemoryBackend, backend));
}
virtual void BroadcastNotifications(
NotificationType type,
history::HistoryDetails* details) OVERRIDE {
// Send the notification on the history thread.
if (NotificationService::current()) {
Details<history::HistoryDetails> det(details);
NotificationService::current()->Notify(type,
NotificationService::AllSources(),
det);
}
// Send the notification to the history service on the main thread.
message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
&HistoryService::BroadcastNotifications, type, details));
}
virtual void DBLoaded() OVERRIDE {
message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
&HistoryService::OnDBLoaded));
}
virtual void StartTopSitesMigration() OVERRIDE {
message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
&HistoryService::StartTopSitesMigration));
}
private:
scoped_refptr<HistoryService> history_service_;
MessageLoop* message_loop_;
};
// static
const history::StarID HistoryService::kBookmarkBarID = 1;
// The history thread is intentionally not a BrowserThread because the
// sync integration unit tests depend on being able to create more than one
// history thread.
HistoryService::HistoryService()
: thread_(new base::Thread(kHistoryThreadName)),
profile_(NULL),
backend_loaded_(false),
bookmark_service_(NULL),
no_db_(false),
needs_top_sites_migration_(false) {
}
HistoryService::HistoryService(Profile* profile)
: thread_(new base::Thread(kHistoryThreadName)),
profile_(profile),
backend_loaded_(false),
bookmark_service_(NULL),
no_db_(false),
needs_top_sites_migration_(false) {
DCHECK(profile_);
registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
Source<Profile>(profile_));
registrar_.Add(this, NotificationType::TEMPLATE_URL_REMOVED,
Source<Profile>(profile_));
}
HistoryService::~HistoryService() {
// Shutdown the backend. This does nothing if Cleanup was already invoked.
Cleanup();
}
bool HistoryService::BackendLoaded() {
// NOTE: We start the backend loading even though it completes asynchronously
// and thus won't affect the return value of this function. This is because
// callers of this assume that if the backend isn't yet loaded it will be
// soon, so they will either listen for notifications or just retry this call
// later. If we've purged the backend, we haven't necessarily restarted it
// loading by now, so we need to trigger the load in order to maintain that
// expectation.
LoadBackendIfNecessary();
return backend_loaded_;
}
void HistoryService::UnloadBackend() {
if (!history_backend_)
return; // Already unloaded.
// Get rid of the in-memory backend.
in_memory_backend_.reset();
// The backend's destructor must run on the history thread since it is not
// threadsafe. So this thread must not be the last thread holding a reference
// to the backend, or a crash could happen.
//
// We have a reference to the history backend. There is also an extra
// reference held by our delegate installed in the backend, which
// HistoryBackend::Closing will release. This means if we scheduled a call
// to HistoryBackend::Closing and *then* released our backend reference, there
// will be a race between us and the backend's Closing function to see who is
// the last holder of a reference. If the backend thread's Closing manages to
// run before we release our backend refptr, the last reference will be held
// by this thread and the destructor will be called from here.
//
// Therefore, we create a task to run the Closing operation first. This holds
// a reference to the backend. Then we release our reference, then we schedule
// the task to run. After the task runs, it will delete its reference from
// the history thread, ensuring everything works properly.
Task* closing_task =
NewRunnableMethod(history_backend_.get(), &HistoryBackend::Closing);
history_backend_ = NULL;
ScheduleTask(PRIORITY_NORMAL, closing_task);
}
void HistoryService::Cleanup() {
if (!thread_) {
// We've already cleaned up.
return;
}
// Unload the backend.
UnloadBackend();
// Delete the thread, which joins with the background thread. We defensively
// NULL the pointer before deleting it in case somebody tries to use it
// during shutdown, but this shouldn't happen.
base::Thread* thread = thread_;
thread_ = NULL;
delete thread;
}
void HistoryService::NotifyRenderProcessHostDestruction(const void* host) {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::NotifyRenderProcessHostDestruction, host);
}
history::URLDatabase* HistoryService::InMemoryDatabase() {
// NOTE: See comments in BackendLoaded() as to why we call
// LoadBackendIfNecessary() here even though it won't affect the return value
// for this call.
LoadBackendIfNecessary();
if (in_memory_backend_.get())
return in_memory_backend_->db();
return NULL;
}
history::InMemoryURLIndex* HistoryService::InMemoryIndex() {
// NOTE: See comments in BackendLoaded() as to why we call
// LoadBackendIfNecessary() here even though it won't affect the return value
// for this call.
LoadBackendIfNecessary();
if (in_memory_backend_.get())
return in_memory_backend_->InMemoryIndex();
return NULL;
}
void HistoryService::SetSegmentPresentationIndex(int64 segment_id, int index) {
ScheduleAndForget(PRIORITY_UI,
&HistoryBackend::SetSegmentPresentationIndex,
segment_id, index);
}
void HistoryService::SetKeywordSearchTermsForURL(const GURL& url,
TemplateURLID keyword_id,
const string16& term) {
ScheduleAndForget(PRIORITY_UI,
&HistoryBackend::SetKeywordSearchTermsForURL,
url, keyword_id, term);
}
void HistoryService::DeleteAllSearchTermsForKeyword(
TemplateURLID keyword_id) {
ScheduleAndForget(PRIORITY_UI,
&HistoryBackend::DeleteAllSearchTermsForKeyword,
keyword_id);
}
HistoryService::Handle HistoryService::GetMostRecentKeywordSearchTerms(
TemplateURLID keyword_id,
const string16& prefix,
int max_count,
CancelableRequestConsumerBase* consumer,
GetMostRecentKeywordSearchTermsCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::GetMostRecentKeywordSearchTerms,
consumer,
new history::GetMostRecentKeywordSearchTermsRequest(callback),
keyword_id, prefix, max_count);
}
void HistoryService::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::URLsNoLongerBookmarked,
urls);
}
HistoryService::Handle HistoryService::ScheduleDBTask(
HistoryDBTask* task,
CancelableRequestConsumerBase* consumer) {
history::HistoryDBTaskRequest* request = new history::HistoryDBTaskRequest(
NewCallback(task, &HistoryDBTask::DoneRunOnMainThread));
request->value = task; // The value is the task to execute.
return Schedule(PRIORITY_UI, &HistoryBackend::ProcessDBTask, consumer,
request);
}
HistoryService::Handle HistoryService::QuerySegmentUsageSince(
CancelableRequestConsumerBase* consumer,
const Time from_time,
int max_result_count,
SegmentQueryCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::QuerySegmentUsage,
consumer, new history::QuerySegmentUsageRequest(callback),
from_time, max_result_count);
}
void HistoryService::SetOnBackendDestroyTask(Task* task) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetOnBackendDestroyTask,
MessageLoop::current(), task);
}
void HistoryService::AddPage(const GURL& url,
const void* id_scope,
int32 page_id,
const GURL& referrer,
PageTransition::Type transition,
const history::RedirectList& redirects,
history::VisitSource visit_source,
bool did_replace_entry) {
AddPage(url, Time::Now(), id_scope, page_id, referrer, transition, redirects,
visit_source, did_replace_entry);
}
void HistoryService::AddPage(const GURL& url,
Time time,
const void* id_scope,
int32 page_id,
const GURL& referrer,
PageTransition::Type transition,
const history::RedirectList& redirects,
history::VisitSource visit_source,
bool did_replace_entry) {
scoped_refptr<history::HistoryAddPageArgs> request(
new history::HistoryAddPageArgs(url, time, id_scope, page_id, referrer,
redirects, transition, visit_source,
did_replace_entry));
AddPage(*request);
}
void HistoryService::AddPage(const history::HistoryAddPageArgs& add_page_args) {
DCHECK(thread_) << "History service being called after cleanup";
// Filter out unwanted URLs. We don't add auto-subframe URLs. They are a
// large part of history (think iframes for ads) and we never display them in
// history UI. We will still add manual subframes, which are ones the user
// has clicked on to get.
if (!CanAddURL(add_page_args.url))
return;
// Add link & all redirects to visited link list.
VisitedLinkMaster* visited_links;
if (profile_ && (visited_links = profile_->GetVisitedLinkMaster())) {
visited_links->AddURL(add_page_args.url);
if (!add_page_args.redirects.empty()) {
// We should not be asked to add a page in the middle of a redirect chain.
DCHECK_EQ(add_page_args.url,
add_page_args.redirects[add_page_args.redirects.size() - 1]);
// We need the !redirects.empty() condition above since size_t is unsigned
// and will wrap around when we subtract one from a 0 size.
for (size_t i = 0; i < add_page_args.redirects.size() - 1; i++)
visited_links->AddURL(add_page_args.redirects[i]);
}
}
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::AddPage,
scoped_refptr<history::HistoryAddPageArgs>(
add_page_args.Clone()));
}
void HistoryService::AddPageNoVisitForBookmark(const GURL& url) {
if (!CanAddURL(url))
return;
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::AddPageNoVisitForBookmark, url);
}
void HistoryService::SetPageTitle(const GURL& url,
const string16& title) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetPageTitle, url, title);
}
void HistoryService::AddPageWithDetails(const GURL& url,
const string16& title,
int visit_count,
int typed_count,
Time last_visit,
bool hidden,
history::VisitSource visit_source) {
// Filter out unwanted URLs.
if (!CanAddURL(url))
return;
// Add to the visited links system.
VisitedLinkMaster* visited_links;
if (profile_ && (visited_links = profile_->GetVisitedLinkMaster()))
visited_links->AddURL(url);
history::URLRow row(url);
row.set_title(title);
row.set_visit_count(visit_count);
row.set_typed_count(typed_count);
row.set_last_visit(last_visit);
row.set_hidden(hidden);
std::vector<history::URLRow> rows;
rows.push_back(row);
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::AddPagesWithDetails, rows, visit_source);
}
void HistoryService::AddPagesWithDetails(
const std::vector<history::URLRow>& info,
history::VisitSource visit_source) {
// Add to the visited links system.
VisitedLinkMaster* visited_links;
if (profile_ && (visited_links = profile_->GetVisitedLinkMaster())) {
std::vector<GURL> urls;
urls.reserve(info.size());
for (std::vector<history::URLRow>::const_iterator i = info.begin();
i != info.end();
++i)
urls.push_back(i->url());
visited_links->AddURLs(urls);
}
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::AddPagesWithDetails, info, visit_source);
}
void HistoryService::SetPageContents(const GURL& url,
const string16& contents) {
if (!CanAddURL(url))
return;
ScheduleAndForget(PRIORITY_LOW, &HistoryBackend::SetPageContents,
url, contents);
}
void HistoryService::SetPageThumbnail(const GURL& page_url,
const SkBitmap& thumbnail,
const ThumbnailScore& score) {
if (!CanAddURL(page_url))
return;
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetPageThumbnail,
page_url, thumbnail, score);
}
HistoryService::Handle HistoryService::GetPageThumbnail(
const GURL& page_url,
CancelableRequestConsumerBase* consumer,
ThumbnailDataCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::GetPageThumbnail, consumer,
new history::GetPageThumbnailRequest(callback), page_url);
}
void HistoryService::GetFavicon(FaviconService::GetFaviconRequest* request,
const GURL& icon_url,
history::IconType icon_type) {
Schedule(PRIORITY_NORMAL, &HistoryBackend::GetFavicon, NULL, request,
icon_url, icon_type);
}
void HistoryService::UpdateFaviconMappingAndFetch(
FaviconService::GetFaviconRequest* request,
const GURL& page_url,
const GURL& icon_url,
history::IconType icon_type) {
Schedule(PRIORITY_NORMAL, &HistoryBackend::UpdateFaviconMappingAndFetch, NULL,
request, page_url, icon_url, history::FAVICON);
}
void HistoryService::GetFaviconForURL(
FaviconService::GetFaviconRequest* request,
const GURL& page_url,
int icon_types) {
Schedule(PRIORITY_NORMAL, &HistoryBackend::GetFaviconForURL, NULL, request,
page_url, icon_types);
}
void HistoryService::SetFavicon(const GURL& page_url,
const GURL& icon_url,
const std::vector<unsigned char>& image_data,
history::IconType icon_type) {
if (!CanAddURL(page_url))
return;
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetFavicon,
page_url, icon_url,
scoped_refptr<RefCountedMemory>(new RefCountedBytes(image_data)),
icon_type);
}
void HistoryService::SetFaviconOutOfDateForPage(const GURL& page_url) {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::SetFaviconOutOfDateForPage, page_url);
}
void HistoryService::SetImportedFavicons(
const std::vector<history::ImportedFaviconUsage>& favicon_usage) {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::SetImportedFavicons, favicon_usage);
}
void HistoryService::IterateURLs(URLEnumerator* enumerator) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
}
HistoryService::Handle HistoryService::QueryURL(
const GURL& url,
bool want_visits,
CancelableRequestConsumerBase* consumer,
QueryURLCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::QueryURL, consumer,
new history::QueryURLRequest(callback), url, want_visits);
}
// Downloads -------------------------------------------------------------------
// Handle creation of a download by creating an entry in the history service's
// 'downloads' table.
HistoryService::Handle HistoryService::CreateDownload(
const DownloadCreateInfo& create_info,
CancelableRequestConsumerBase* consumer,
HistoryService::DownloadCreateCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::CreateDownload, consumer,
new history::DownloadCreateRequest(callback), create_info);
}
// Handle queries for a list of all downloads in the history database's
// 'downloads' table.
HistoryService::Handle HistoryService::QueryDownloads(
CancelableRequestConsumerBase* consumer,
DownloadQueryCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryDownloads, consumer,
new history::DownloadQueryRequest(callback));
}
// Changes all IN_PROGRESS in the database entries to CANCELED.
// IN_PROGRESS entries are the corrupted entries, not updated by next function
// because of the crash or some other extremal exit.
void HistoryService::CleanUpInProgressEntries() {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::CleanUpInProgressEntries);
}
// Handle updates for a particular download. This is a 'fire and forget'
// operation, so we don't need to be called back.
void HistoryService::UpdateDownload(int64 received_bytes,
int32 state,
int64 db_handle) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownload,
received_bytes, state, db_handle);
}
void HistoryService::UpdateDownloadPath(const FilePath& path,
int64 db_handle) {
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownloadPath,
path, db_handle);
}
void HistoryService::RemoveDownload(int64 db_handle) {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::RemoveDownload, db_handle);
}
void HistoryService::RemoveDownloadsBetween(Time remove_begin,
Time remove_end) {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::RemoveDownloadsBetween,
remove_begin,
remove_end);
}
HistoryService::Handle HistoryService::QueryHistory(
const string16& text_query,
const history::QueryOptions& options,
CancelableRequestConsumerBase* consumer,
QueryHistoryCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::QueryHistory, consumer,
new history::QueryHistoryRequest(callback),
text_query, options);
}
HistoryService::Handle HistoryService::QueryRedirectsFrom(
const GURL& from_url,
CancelableRequestConsumerBase* consumer,
QueryRedirectsCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::QueryRedirectsFrom, consumer,
new history::QueryRedirectsRequest(callback), from_url);
}
HistoryService::Handle HistoryService::QueryRedirectsTo(
const GURL& to_url,
CancelableRequestConsumerBase* consumer,
QueryRedirectsCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryRedirectsTo, consumer,
new history::QueryRedirectsRequest(callback), to_url);
}
HistoryService::Handle HistoryService::GetVisitCountToHost(
const GURL& url,
CancelableRequestConsumerBase* consumer,
GetVisitCountToHostCallback* callback) {
return Schedule(PRIORITY_UI, &HistoryBackend::GetVisitCountToHost, consumer,
new history::GetVisitCountToHostRequest(callback), url);
}
HistoryService::Handle HistoryService::QueryTopURLsAndRedirects(
int result_count,
CancelableRequestConsumerBase* consumer,
QueryTopURLsAndRedirectsCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryTopURLsAndRedirects,
consumer, new history::QueryTopURLsAndRedirectsRequest(callback),
result_count);
}
HistoryService::Handle HistoryService::QueryMostVisitedURLs(
int result_count,
int days_back,
CancelableRequestConsumerBase* consumer,
QueryMostVisitedURLsCallback* callback) {
return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryMostVisitedURLs,
consumer,
new history::QueryMostVisitedURLsRequest(callback),
result_count, days_back);
}
void HistoryService::Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details) {
if (!thread_)
return;
switch (type.value) {
case NotificationType::HISTORY_URLS_DELETED: {
// Update the visited link system for deleted URLs. We will update the
// visited link system for added URLs as soon as we get the add
// notification (we don't have to wait for the backend, which allows us to
// be faster to update the state).
//
// For deleted URLs, we don't typically know what will be deleted since
// delete notifications are by time. We would also like to be more
// respectful of privacy and never tell the user something is gone when it
// isn't. Therefore, we update the delete URLs after the fact.
if (!profile_)
return; // No profile, probably unit testing.
Details<history::URLsDeletedDetails> deleted_details(details);
VisitedLinkMaster* visited_links = profile_->GetVisitedLinkMaster();
if (!visited_links)
return; // Nobody to update.
if (deleted_details->all_history)
visited_links->DeleteAllURLs();
else // Delete individual ones.
visited_links->DeleteURLs(deleted_details->urls);
break;
}
case NotificationType::TEMPLATE_URL_REMOVED:
DeleteAllSearchTermsForKeyword(*(Details<TemplateURLID>(details).ptr()));
break;
default:
NOTREACHED();
}
}
bool HistoryService::Init(const FilePath& history_dir,
BookmarkService* bookmark_service,
bool no_db) {
if (!thread_->Start()) {
Cleanup();
return false;
}
history_dir_ = history_dir;
bookmark_service_ = bookmark_service;
no_db_ = no_db;
// Create the history backend.
LoadBackendIfNecessary();
return true;
}
void HistoryService::ScheduleAutocomplete(HistoryURLProvider* provider,
HistoryURLProviderParams* params) {
ScheduleAndForget(PRIORITY_UI, &HistoryBackend::ScheduleAutocomplete,
scoped_refptr<HistoryURLProvider>(provider), params);
}
void HistoryService::ScheduleTask(SchedulePriority priority,
Task* task) {
// TODO(brettw): do prioritization.
thread_->message_loop()->PostTask(FROM_HERE, task);
}
// static
bool HistoryService::CanAddURL(const GURL& url) {
if (!url.is_valid())
return false;
// TODO: We should allow kChromeUIScheme URLs if they have been explicitly
// typed. Right now, however, these are marked as typed even when triggered
// by a shortcut or menu action.
if (url.SchemeIs(chrome::kJavaScriptScheme) ||
url.SchemeIs(chrome::kChromeDevToolsScheme) ||
url.SchemeIs(chrome::kChromeUIScheme) ||
url.SchemeIs(chrome::kViewSourceScheme) ||
url.SchemeIs(chrome::kChromeInternalScheme))
return false;
if (url.SchemeIs(chrome::kAboutScheme)) {
if (LowerCaseEqualsASCII(url.path(), "blank"))
return false;
// We allow all other about URLs since the user may like to see things
// like "about:memory" or "about:histograms" in their history and
// autocomplete.
}
return true;
}
void HistoryService::SetInMemoryBackend(
history::InMemoryHistoryBackend* mem_backend) {
DCHECK(!in_memory_backend_.get()) << "Setting mem DB twice";
in_memory_backend_.reset(mem_backend);
// The database requires additional initialization once we own it.
in_memory_backend_->AttachToHistoryService(profile_);
}
void HistoryService::NotifyProfileError(sql::InitStatus init_status) {
ShowProfileErrorDialog(
(init_status == sql::INIT_FAILURE) ?
IDS_COULDNT_OPEN_PROFILE_ERROR : IDS_PROFILE_TOO_NEW_ERROR);
}
void HistoryService::DeleteURL(const GURL& url) {
// We will update the visited links when we observe the delete notifications.
ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURL, url);
}
void HistoryService::ExpireHistoryBetween(
const std::set<GURL>& restrict_urls,
Time begin_time, Time end_time,
CancelableRequestConsumerBase* consumer,
ExpireHistoryCallback* callback) {
// We will update the visited links when we observe the delete notifications.
Schedule(PRIORITY_UI, &HistoryBackend::ExpireHistoryBetween, consumer,
new history::ExpireHistoryRequest(callback),
restrict_urls, begin_time, end_time);
}
void HistoryService::BroadcastNotifications(
NotificationType type,
history::HistoryDetails* details_deleted) {
// We take ownership of the passed-in pointer and delete it. It was made for
// us on another thread, so the caller doesn't know when we will handle it.
scoped_ptr<history::HistoryDetails> details(details_deleted);
// TODO(evanm): this is currently necessitated by generate_profile, which
// runs without a browser process. generate_profile should really create
// a browser process, at which point this check can then be nuked.
if (!g_browser_process)
return;
if (!thread_)
return;
// The source of all of our notifications is the profile. Note that this
// pointer is NULL in unit tests.
Source<Profile> source(profile_);
// The details object just contains the pointer to the object that the
// backend has allocated for us. The receiver of the notification will cast
// this to the proper type.
Details<history::HistoryDetails> det(details_deleted);
NotificationService::current()->Notify(type, source, det);
}
void HistoryService::LoadBackendIfNecessary() {
if (!thread_ || history_backend_)
return; // Failed to init, or already started loading.
scoped_refptr<HistoryBackend> backend(
new HistoryBackend(history_dir_,
new BackendDelegate(this),
bookmark_service_));
history_backend_.swap(backend);
// There may not be a profile when unit testing.
std::string languages;
if (profile_) {
PrefService* prefs = profile_->GetPrefs();
languages = prefs->GetString(prefs::kAcceptLanguages);
}
ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_);
}
void HistoryService::OnDBLoaded() {
backend_loaded_ = true;
NotificationService::current()->Notify(NotificationType::HISTORY_LOADED,
Source<Profile>(profile_),
Details<HistoryService>(this));
if (thread_ && profile_) {
// We don't want to force creation of TopSites.
history::TopSites* ts = profile_->GetTopSitesWithoutCreating();
if (ts)
ts->HistoryLoaded();
}
}
void HistoryService::StartTopSitesMigration() {
needs_top_sites_migration_ = true;
if (thread_ && profile_) {
// We don't want to force creation of TopSites.
history::TopSites* ts = profile_->GetTopSitesWithoutCreating();
if (ts)
ts->MigrateFromHistory();
}
}
void HistoryService::OnTopSitesReady() {
ScheduleAndForget(PRIORITY_NORMAL,
&HistoryBackend::MigrateThumbnailsDatabase);
}