src/chrome/browser/history/history_service.cc

   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.
   4
   5 // The history system runs on a background thread so that potentially slow
   6 // database operations don't delay the browser. This backend processing is
   7 // represented by HistoryBackend. The HistoryService's job is to dispatch to
   8 // that thread.
   9 //
  10 // Main thread                       History thread
  11 // -----------                       --------------
  12 // HistoryService <----------------> HistoryBackend
  13 //                                   -> HistoryDatabase
  14 //                                      -> SQLite connection to History
  15 //                                   -> ThumbnailDatabase
  16 //                                      -> SQLite connection to Thumbnails
  17 //                                         (and favicons)
  18
  19 #include "chrome/browser/history/history_service.h"
  20
  21 #include "base/bind_helpers.h"
  22 #include "base/callback.h"
  23 #include "base/command_line.h"
  24 #include "base/compiler_specific.h"
  25 #include "base/location.h"
  26 #include "base/memory/ref_counted.h"
  27 #include "base/message_loop/message_loop.h"
  28 #include "base/path_service.h"
  29 #include "base/prefs/pref_service.h"
  30 #include "base/thread_task_runner_handle.h"
  31 #include "base/threading/thread.h"
  32 #include "base/time/time.h"
  33 #include "chrome/browser/browser_process.h"
  34 #include "chrome/browser/chrome_notification_types.h"
  35 #include "chrome/browser/history/download_row.h"
  36 #include "chrome/browser/history/history_backend.h"
  37 #include "chrome/browser/history/history_notifications.h"
  38 #include "chrome/browser/history/in_memory_history_backend.h"
  39 #include "chrome/browser/history/in_memory_url_index.h"
  40 #include "chrome/browser/history/top_sites.h"
  41 #include "chrome/browser/history/visit_database.h"
  42 #include "chrome/browser/history/visit_filter.h"
  43 #include "chrome/browser/history/web_history_service.h"
  44 #include "chrome/browser/history/web_history_service_factory.h"
  45 #include "chrome/browser/profiles/profile.h"
  46 #include "chrome/common/chrome_constants.h"
  47 #include "chrome/common/chrome_switches.h"
  48 #include "chrome/common/importer/imported_favicon_usage.h"
  49 #include "chrome/common/pref_names.h"
  50 #include "chrome/common/url_constants.h"
  51 #include "components/dom_distiller/core/url_constants.h"
  52 #include "components/history/core/browser/history_client.h"
  53 #include "components/history/core/browser/history_types.h"
  54 #include "components/history/core/browser/in_memory_database.h"
  55 #include "components/history/core/browser/keyword_search_term.h"
  56 #include "components/history/core/common/thumbnail_score.h"
  57 #include "components/visitedlink/browser/visitedlink_master.h"
  58 #include "content/public/browser/browser_thread.h"
  59 #include "content/public/browser/download_item.h"
  60 #include "content/public/browser/notification_service.h"
  61 #include "sync/api/sync_error_factory.h"
  62 #include "third_party/skia/include/core/SkBitmap.h"
  63
  64 using base::Time;
  65 using history::HistoryBackend;
  66 using history::KeywordID;
  67
  68 namespace {
  69
  70 static const char* kHistoryThreadName = "Chrome_HistoryThread";
  71
  72 void RunWithFaviconResults(
  73     const favicon_base::FaviconResultsCallback& callback,
  74     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
  75   callback.Run(*bitmap_results);
  76 }
  77
  78 void RunWithFaviconResult(
  79     const favicon_base::FaviconRawBitmapCallback& callback,
  80     favicon_base::FaviconRawBitmapResult* bitmap_result) {
  81   callback.Run(*bitmap_result);
  82 }
  83
  84 void RunWithQueryURLResult(const HistoryService::QueryURLCallback& callback,
  85                            const history::QueryURLResult* result) {
  86   callback.Run(result->success, result->row, result->visits);
  87 }
  88
  89 void RunWithVisibleVisitCountToHostResult(
  90     const HistoryService::GetVisibleVisitCountToHostCallback& callback,
  91     const history::VisibleVisitCountToHostResult* result) {
  92   callback.Run(result->success, result->count, result->first_visit);
  93 }
  94
  95 // Extract history::URLRows into GURLs for VisitedLinkMaster.
  96 class URLIteratorFromURLRows
  97     : public visitedlink::VisitedLinkMaster::URLIterator {
  98  public:
  99   explicit URLIteratorFromURLRows(const history::URLRows& url_rows)
 100       : itr_(url_rows.begin()),
 101         end_(url_rows.end()) {
 102   }
 103
 104   virtual const GURL& NextURL() OVERRIDE {
 105     return (itr_++)->url();
 106   }
 107
 108   virtual bool HasNextURL() const OVERRIDE {
 109     return itr_ != end_;
 110   }
 111
 112  private:
 113   history::URLRows::const_iterator itr_;
 114   history::URLRows::const_iterator end_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(URLIteratorFromURLRows);
 117 };
 118
 119 // Callback from WebHistoryService::ExpireWebHistory().
 120 void ExpireWebHistoryComplete(bool success) {
 121   // Ignore the result.
 122   //
 123   // TODO(davidben): ExpireLocalAndRemoteHistoryBetween callback should not fire
 124   // until this completes.
 125 }
 126
 127 }  // namespace
 128
 129 // Sends messages from the backend to us on the main thread. This must be a
 130 // separate class from the history service so that it can hold a reference to
 131 // the history service (otherwise we would have to manually AddRef and
 132 // Release when the Backend has a reference to us).
 133 class HistoryService::BackendDelegate : public HistoryBackend::Delegate {
 134  public:
 135   BackendDelegate(
 136       const base::WeakPtr<HistoryService>& history_service,
 137       const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
 138       Profile* profile)
 139       : history_service_(history_service),
 140         service_task_runner_(service_task_runner),
 141         profile_(profile) {
 142   }
 143
 144   virtual void NotifyProfileError(sql::InitStatus init_status) OVERRIDE {
 145     // Send to the history service on the main thread.
 146     service_task_runner_->PostTask(
 147         FROM_HERE,
 148         base::Bind(&HistoryService::NotifyProfileError, history_service_,
 149                    init_status));
 150   }
 151
 152   virtual void SetInMemoryBackend(
 153       scoped_ptr<history::InMemoryHistoryBackend> backend) OVERRIDE {
 154     // Send the backend to the history service on the main thread.
 155     service_task_runner_->PostTask(
 156         FROM_HERE,
 157         base::Bind(&HistoryService::SetInMemoryBackend, history_service_,
 158                    base::Passed(&backend)));
 159   }
 160
 161   virtual void NotifyFaviconChanged(const std::set<GURL>& urls) OVERRIDE {
 162     // Send the notification to the history service on the main thread.
 163     service_task_runner_->PostTask(
 164         FROM_HERE,
 165         base::Bind(
 166             &HistoryService::NotifyFaviconChanged, history_service_, urls));
 167   }
 168
 169   virtual void BroadcastNotifications(
 170       int type,
 171       scoped_ptr<history::HistoryDetails> details) OVERRIDE {
 172     // Send the notification on the history thread.
 173     if (content::NotificationService::current()) {
 174       content::Details<history::HistoryDetails> det(details.get());
 175       content::NotificationService::current()->Notify(
 176           type, content::Source<Profile>(profile_), det);
 177     }
 178     // Send the notification to the history service on the main thread.
 179     service_task_runner_->PostTask(
 180         FROM_HERE,
 181         base::Bind(&HistoryService::BroadcastNotificationsHelper,
 182                    history_service_, type, base::Passed(&details)));
 183   }
 184
 185   virtual void DBLoaded() OVERRIDE {
 186     service_task_runner_->PostTask(
 187         FROM_HERE,
 188         base::Bind(&HistoryService::OnDBLoaded, history_service_));
 189   }
 190
 191   virtual void NotifyVisitDBObserversOnAddVisit(
 192       const history::BriefVisitInfo& info) OVERRIDE {
 193     service_task_runner_->PostTask(
 194         FROM_HERE,
 195         base::Bind(&HistoryService::NotifyVisitDBObserversOnAddVisit,
 196                    history_service_, info));
 197   }
 198
 199  private:
 200   const base::WeakPtr<HistoryService> history_service_;
 201   const scoped_refptr<base::SequencedTaskRunner> service_task_runner_;
 202   Profile* const profile_;
 203 };
 204
 205 // The history thread is intentionally not a BrowserThread because the
 206 // sync integration unit tests depend on being able to create more than one
 207 // history thread.
 208 HistoryService::HistoryService()
 209     : thread_(new base::Thread(kHistoryThreadName)),
 210       history_client_(NULL),
 211       profile_(NULL),
 212       backend_loaded_(false),
 213       no_db_(false),
 214       weak_ptr_factory_(this) {
 215 }
 216
 217 HistoryService::HistoryService(history::HistoryClient* client, Profile* profile)
 218     : thread_(new base::Thread(kHistoryThreadName)),
 219       history_client_(client),
 220       profile_(profile),
 221       visitedlink_master_(new visitedlink::VisitedLinkMaster(
 222           profile, this, true)),
 223       backend_loaded_(false),
 224       no_db_(false),
 225       weak_ptr_factory_(this) {
 226   DCHECK(profile_);
 227   registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
 228                  content::Source<Profile>(profile_));
 229 }
 230
 231 HistoryService::~HistoryService() {
 232   DCHECK(thread_checker_.CalledOnValidThread());
 233   // Shutdown the backend. This does nothing if Cleanup was already invoked.
 234   Cleanup();
 235 }
 236
 237 bool HistoryService::BackendLoaded() {
 238   DCHECK(thread_checker_.CalledOnValidThread());
 239   return backend_loaded_;
 240 }
 241
 242 void HistoryService::ClearCachedDataForContextID(
 243     history::ContextID context_id) {
 244   DCHECK(thread_) << "History service being called after cleanup";
 245   DCHECK(thread_checker_.CalledOnValidThread());
 246   ScheduleAndForget(PRIORITY_NORMAL,
 247                     &HistoryBackend::ClearCachedDataForContextID, context_id);
 248 }
 249
 250 history::URLDatabase* HistoryService::InMemoryDatabase() {
 251   DCHECK(thread_checker_.CalledOnValidThread());
 252   return in_memory_backend_ ? in_memory_backend_->db() : NULL;
 253 }
 254
 255 bool HistoryService::GetTypedCountForURL(const GURL& url, int* typed_count) {
 256   DCHECK(thread_checker_.CalledOnValidThread());
 257   history::URLRow url_row;
 258   if (!GetRowForURL(url, &url_row))
 259     return false;
 260   *typed_count = url_row.typed_count();
 261   return true;
 262 }
 263
 264 bool HistoryService::GetLastVisitTimeForURL(const GURL& url,
 265                                             base::Time* last_visit) {
 266   DCHECK(thread_checker_.CalledOnValidThread());
 267   history::URLRow url_row;
 268   if (!GetRowForURL(url, &url_row))
 269     return false;
 270   *last_visit = url_row.last_visit();
 271   return true;
 272 }
 273
 274 bool HistoryService::GetVisitCountForURL(const GURL& url, int* visit_count) {
 275   DCHECK(thread_checker_.CalledOnValidThread());
 276   history::URLRow url_row;
 277   if (!GetRowForURL(url, &url_row))
 278     return false;
 279   *visit_count = url_row.visit_count();
 280   return true;
 281 }
 282
 283 history::TypedUrlSyncableService* HistoryService::GetTypedUrlSyncableService()
 284     const {
 285   return history_backend_->GetTypedUrlSyncableService();
 286 }
 287
 288 void HistoryService::Shutdown() {
 289   DCHECK(thread_checker_.CalledOnValidThread());
 290   Cleanup();
 291 }
 292
 293 void HistoryService::SetKeywordSearchTermsForURL(const GURL& url,
 294                                                  KeywordID keyword_id,
 295                                                  const base::string16& term) {
 296   DCHECK(thread_) << "History service being called after cleanup";
 297   DCHECK(thread_checker_.CalledOnValidThread());
 298   ScheduleAndForget(PRIORITY_UI,
 299                     &HistoryBackend::SetKeywordSearchTermsForURL,
 300                     url, keyword_id, term);
 301 }
 302
 303 void HistoryService::DeleteAllSearchTermsForKeyword(KeywordID keyword_id) {
 304   DCHECK(thread_) << "History service being called after cleanup";
 305   DCHECK(thread_checker_.CalledOnValidThread());
 306
 307   if (in_memory_backend_)
 308     in_memory_backend_->DeleteAllSearchTermsForKeyword(keyword_id);
 309
 310   ScheduleAndForget(PRIORITY_UI,
 311                     &HistoryBackend::DeleteAllSearchTermsForKeyword,
 312                     keyword_id);
 313 }
 314
 315 void HistoryService::DeleteKeywordSearchTermForURL(const GURL& url) {
 316   DCHECK(thread_) << "History service being called after cleanup";
 317   DCHECK(thread_checker_.CalledOnValidThread());
 318   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::DeleteKeywordSearchTermForURL,
 319                     url);
 320 }
 321
 322 void HistoryService::DeleteMatchingURLsForKeyword(KeywordID keyword_id,
 323                                                   const base::string16& term) {
 324   DCHECK(thread_) << "History service being called after cleanup";
 325   DCHECK(thread_checker_.CalledOnValidThread());
 326   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::DeleteMatchingURLsForKeyword,
 327                     keyword_id, term);
 328 }
 329
 330 void HistoryService::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
 331   DCHECK(thread_) << "History service being called after cleanup";
 332   DCHECK(thread_checker_.CalledOnValidThread());
 333   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::URLsNoLongerBookmarked,
 334                     urls);
 335 }
 336
 337 void HistoryService::ScheduleDBTask(scoped_ptr<history::HistoryDBTask> task,
 338                                     base::CancelableTaskTracker* tracker) {
 339   DCHECK(thread_) << "History service being called after cleanup";
 340   DCHECK(thread_checker_.CalledOnValidThread());
 341   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
 342   tracker->NewTrackedTaskId(&is_canceled);
 343   // Use base::ThreadTaskRunnerHandler::Get() to get a message loop proxy to
 344   // the current message loop so that we can forward the call to the method
 345   // HistoryDBTask::DoneRunOnMainThread in the correct thread.
 346   thread_->message_loop_proxy()->PostTask(
 347       FROM_HERE,
 348       base::Bind(&HistoryBackend::ProcessDBTask,
 349                  history_backend_.get(),
 350                  base::Passed(&task),
 351                  base::ThreadTaskRunnerHandle::Get(),
 352                  is_canceled));
 353 }
 354
 355 void HistoryService::FlushForTest(const base::Closure& flushed) {
 356   thread_->message_loop_proxy()->PostTaskAndReply(
 357       FROM_HERE, base::Bind(&base::DoNothing), flushed);
 358 }
 359
 360 void HistoryService::SetOnBackendDestroyTask(const base::Closure& task) {
 361   DCHECK(thread_) << "History service being called after cleanup";
 362   DCHECK(thread_checker_.CalledOnValidThread());
 363   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetOnBackendDestroyTask,
 364                     base::MessageLoop::current(), task);
 365 }
 366
 367 void HistoryService::AddPage(const GURL& url,
 368                              Time time,
 369                              history::ContextID context_id,
 370                              int32 page_id,
 371                              const GURL& referrer,
 372                              const history::RedirectList& redirects,
 373                              ui::PageTransition transition,
 374                              history::VisitSource visit_source,
 375                              bool did_replace_entry) {
 376   DCHECK(thread_checker_.CalledOnValidThread());
 377   AddPage(
 378       history::HistoryAddPageArgs(url, time, context_id, page_id, referrer,
 379                                   redirects, transition, visit_source,
 380                                   did_replace_entry));
 381 }
 382
 383 void HistoryService::AddPage(const GURL& url,
 384                              base::Time time,
 385                              history::VisitSource visit_source) {
 386   DCHECK(thread_checker_.CalledOnValidThread());
 387   AddPage(
 388       history::HistoryAddPageArgs(url, time, NULL, 0, GURL(),
 389                                   history::RedirectList(),
 390                                   ui::PAGE_TRANSITION_LINK,
 391                                   visit_source, false));
 392 }
 393
 394 void HistoryService::AddPage(const history::HistoryAddPageArgs& add_page_args) {
 395   DCHECK(thread_) << "History service being called after cleanup";
 396   DCHECK(thread_checker_.CalledOnValidThread());
 397
 398   // Filter out unwanted URLs. We don't add auto-subframe URLs. They are a
 399   // large part of history (think iframes for ads) and we never display them in
 400   // history UI. We will still add manual subframes, which are ones the user
 401   // has clicked on to get.
 402   if (!CanAddURL(add_page_args.url))
 403     return;
 404
 405   // Add link & all redirects to visited link list.
 406   if (visitedlink_master_) {
 407     visitedlink_master_->AddURL(add_page_args.url);
 408
 409     if (!add_page_args.redirects.empty()) {
 410       // We should not be asked to add a page in the middle of a redirect chain.
 411       DCHECK_EQ(add_page_args.url,
 412                 add_page_args.redirects[add_page_args.redirects.size() - 1]);
 413
 414       // We need the !redirects.empty() condition above since size_t is unsigned
 415       // and will wrap around when we subtract one from a 0 size.
 416       for (size_t i = 0; i < add_page_args.redirects.size() - 1; i++)
 417         visitedlink_master_->AddURL(add_page_args.redirects[i]);
 418     }
 419   }
 420
 421   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::AddPage, add_page_args);
 422 }
 423
 424 void HistoryService::AddPageNoVisitForBookmark(const GURL& url,
 425                                                const base::string16& title) {
 426   DCHECK(thread_) << "History service being called after cleanup";
 427   DCHECK(thread_checker_.CalledOnValidThread());
 428   if (!CanAddURL(url))
 429     return;
 430
 431   ScheduleAndForget(PRIORITY_NORMAL,
 432                     &HistoryBackend::AddPageNoVisitForBookmark, url, title);
 433 }
 434
 435 void HistoryService::SetPageTitle(const GURL& url,
 436                                   const base::string16& title) {
 437   DCHECK(thread_) << "History service being called after cleanup";
 438   DCHECK(thread_checker_.CalledOnValidThread());
 439   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetPageTitle, url, title);
 440 }
 441
 442 void HistoryService::UpdateWithPageEndTime(history::ContextID context_id,
 443                                            int32 page_id,
 444                                            const GURL& url,
 445                                            Time end_ts) {
 446   DCHECK(thread_) << "History service being called after cleanup";
 447   DCHECK(thread_checker_.CalledOnValidThread());
 448   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateWithPageEndTime,
 449                     context_id, page_id, url, end_ts);
 450 }
 451
 452 void HistoryService::AddPageWithDetails(const GURL& url,
 453                                         const base::string16& title,
 454                                         int visit_count,
 455                                         int typed_count,
 456                                         Time last_visit,
 457                                         bool hidden,
 458                                         history::VisitSource visit_source) {
 459   DCHECK(thread_) << "History service being called after cleanup";
 460   DCHECK(thread_checker_.CalledOnValidThread());
 461   // Filter out unwanted URLs.
 462   if (!CanAddURL(url))
 463     return;
 464
 465   // Add to the visited links system.
 466   if (visitedlink_master_)
 467     visitedlink_master_->AddURL(url);
 468
 469   history::URLRow row(url);
 470   row.set_title(title);
 471   row.set_visit_count(visit_count);
 472   row.set_typed_count(typed_count);
 473   row.set_last_visit(last_visit);
 474   row.set_hidden(hidden);
 475
 476   history::URLRows rows;
 477   rows.push_back(row);
 478
 479   ScheduleAndForget(PRIORITY_NORMAL,
 480                     &HistoryBackend::AddPagesWithDetails, rows, visit_source);
 481 }
 482
 483 void HistoryService::AddPagesWithDetails(const history::URLRows& info,
 484                                          history::VisitSource visit_source) {
 485   DCHECK(thread_) << "History service being called after cleanup";
 486   DCHECK(thread_checker_.CalledOnValidThread());
 487   // Add to the visited links system.
 488   if (visitedlink_master_) {
 489     std::vector<GURL> urls;
 490     urls.reserve(info.size());
 491     for (history::URLRows::const_iterator i = info.begin(); i != info.end();
 492          ++i)
 493       urls.push_back(i->url());
 494
 495     visitedlink_master_->AddURLs(urls);
 496   }
 497
 498   ScheduleAndForget(PRIORITY_NORMAL,
 499                     &HistoryBackend::AddPagesWithDetails, info, visit_source);
 500 }
 501
 502 base::CancelableTaskTracker::TaskId HistoryService::GetFavicons(
 503     const std::vector<GURL>& icon_urls,
 504     int icon_types,
 505     const std::vector<int>& desired_sizes,
 506     const favicon_base::FaviconResultsCallback& callback,
 507     base::CancelableTaskTracker* tracker) {
 508   DCHECK(thread_) << "History service being called after cleanup";
 509   DCHECK(thread_checker_.CalledOnValidThread());
 510   std::vector<favicon_base::FaviconRawBitmapResult>* results =
 511       new std::vector<favicon_base::FaviconRawBitmapResult>();
 512   return tracker->PostTaskAndReply(
 513       thread_->message_loop_proxy().get(),
 514       FROM_HERE,
 515       base::Bind(&HistoryBackend::GetFavicons,
 516                  history_backend_.get(),
 517                  icon_urls,
 518                  icon_types,
 519                  desired_sizes,
 520                  results),
 521       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 522 }
 523
 524 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
 525     const GURL& page_url,
 526     int icon_types,
 527     const std::vector<int>& desired_sizes,
 528     const favicon_base::FaviconResultsCallback& callback,
 529     base::CancelableTaskTracker* tracker) {
 530   DCHECK(thread_) << "History service being called after cleanup";
 531   DCHECK(thread_checker_.CalledOnValidThread());
 532   std::vector<favicon_base::FaviconRawBitmapResult>* results =
 533       new std::vector<favicon_base::FaviconRawBitmapResult>();
 534   return tracker->PostTaskAndReply(
 535       thread_->message_loop_proxy().get(),
 536       FROM_HERE,
 537       base::Bind(&HistoryBackend::GetFaviconsForURL,
 538                  history_backend_.get(),
 539                  page_url,
 540                  icon_types,
 541                  desired_sizes,
 542                  results),
 543       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 544 }
 545
 546 base::CancelableTaskTracker::TaskId HistoryService::GetLargestFaviconForURL(
 547     const GURL& page_url,
 548     const std::vector<int>& icon_types,
 549     int minimum_size_in_pixels,
 550     const favicon_base::FaviconRawBitmapCallback& callback,
 551     base::CancelableTaskTracker* tracker) {
 552   DCHECK(thread_) << "History service being called after cleanup";
 553   DCHECK(thread_checker_.CalledOnValidThread());
 554   favicon_base::FaviconRawBitmapResult* result =
 555       new favicon_base::FaviconRawBitmapResult();
 556   return tracker->PostTaskAndReply(
 557       thread_->message_loop_proxy().get(),
 558       FROM_HERE,
 559       base::Bind(&HistoryBackend::GetLargestFaviconForURL,
 560                  history_backend_.get(),
 561                  page_url,
 562                  icon_types,
 563                  minimum_size_in_pixels,
 564                  result),
 565       base::Bind(&RunWithFaviconResult, callback, base::Owned(result)));
 566 }
 567
 568 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
 569     favicon_base::FaviconID favicon_id,
 570     int desired_size,
 571     const favicon_base::FaviconResultsCallback& callback,
 572     base::CancelableTaskTracker* tracker) {
 573   DCHECK(thread_) << "History service being called after cleanup";
 574   DCHECK(thread_checker_.CalledOnValidThread());
 575   std::vector<favicon_base::FaviconRawBitmapResult>* results =
 576       new std::vector<favicon_base::FaviconRawBitmapResult>();
 577   return tracker->PostTaskAndReply(
 578       thread_->message_loop_proxy().get(),
 579       FROM_HERE,
 580       base::Bind(&HistoryBackend::GetFaviconForID,
 581                  history_backend_.get(),
 582                  favicon_id,
 583                  desired_size,
 584                  results),
 585       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 586 }
 587
 588 base::CancelableTaskTracker::TaskId
 589 HistoryService::UpdateFaviconMappingsAndFetch(
 590     const GURL& page_url,
 591     const std::vector<GURL>& icon_urls,
 592     int icon_types,
 593     const std::vector<int>& desired_sizes,
 594     const favicon_base::FaviconResultsCallback& callback,
 595     base::CancelableTaskTracker* tracker) {
 596   DCHECK(thread_) << "History service being called after cleanup";
 597   DCHECK(thread_checker_.CalledOnValidThread());
 598   std::vector<favicon_base::FaviconRawBitmapResult>* results =
 599       new std::vector<favicon_base::FaviconRawBitmapResult>();
 600   return tracker->PostTaskAndReply(
 601       thread_->message_loop_proxy().get(),
 602       FROM_HERE,
 603       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
 604                  history_backend_.get(),
 605                  page_url,
 606                  icon_urls,
 607                  icon_types,
 608                  desired_sizes,
 609                  results),
 610       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 611 }
 612
 613 void HistoryService::MergeFavicon(
 614     const GURL& page_url,
 615     const GURL& icon_url,
 616     favicon_base::IconType icon_type,
 617     scoped_refptr<base::RefCountedMemory> bitmap_data,
 618     const gfx::Size& pixel_size) {
 619   DCHECK(thread_) << "History service being called after cleanup";
 620   DCHECK(thread_checker_.CalledOnValidThread());
 621   if (!CanAddURL(page_url))
 622     return;
 623
 624   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::MergeFavicon, page_url,
 625                     icon_url, icon_type, bitmap_data, pixel_size);
 626 }
 627
 628 void HistoryService::SetFavicons(
 629     const GURL& page_url,
 630     favicon_base::IconType icon_type,
 631     const GURL& icon_url,
 632     const std::vector<SkBitmap>& bitmaps) {
 633   DCHECK(thread_) << "History service being called after cleanup";
 634   DCHECK(thread_checker_.CalledOnValidThread());
 635   if (!CanAddURL(page_url))
 636     return;
 637
 638   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetFavicons, page_url,
 639       icon_type, icon_url, bitmaps);
 640 }
 641
 642 void HistoryService::SetFaviconsOutOfDateForPage(const GURL& page_url) {
 643   DCHECK(thread_) << "History service being called after cleanup";
 644   DCHECK(thread_checker_.CalledOnValidThread());
 645   ScheduleAndForget(PRIORITY_NORMAL,
 646                     &HistoryBackend::SetFaviconsOutOfDateForPage, page_url);
 647 }
 648
 649 void HistoryService::CloneFavicons(const GURL& old_page_url,
 650                                    const GURL& new_page_url) {
 651   DCHECK(thread_) << "History service being called after cleanup";
 652   DCHECK(thread_checker_.CalledOnValidThread());
 653   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::CloneFavicons,
 654                     old_page_url, new_page_url);
 655 }
 656
 657 void HistoryService::SetImportedFavicons(
 658     const std::vector<ImportedFaviconUsage>& favicon_usage) {
 659   DCHECK(thread_) << "History service being called after cleanup";
 660   DCHECK(thread_checker_.CalledOnValidThread());
 661   ScheduleAndForget(PRIORITY_NORMAL,
 662                     &HistoryBackend::SetImportedFavicons, favicon_usage);
 663 }
 664
 665 base::CancelableTaskTracker::TaskId HistoryService::QueryURL(
 666     const GURL& url,
 667     bool want_visits,
 668     const QueryURLCallback& callback,
 669     base::CancelableTaskTracker* tracker) {
 670   DCHECK(thread_) << "History service being called after cleanup";
 671   DCHECK(thread_checker_.CalledOnValidThread());
 672   history::QueryURLResult* query_url_result = new history::QueryURLResult();
 673   return tracker->PostTaskAndReply(
 674       thread_->message_loop_proxy().get(),
 675       FROM_HERE,
 676       base::Bind(&HistoryBackend::QueryURL,
 677                  history_backend_.get(),
 678                  url,
 679                  want_visits,
 680                  base::Unretained(query_url_result)),
 681       base::Bind(
 682           &RunWithQueryURLResult, callback, base::Owned(query_url_result)));
 683 }
 684
 685 // Downloads -------------------------------------------------------------------
 686
 687 // Handle creation of a download by creating an entry in the history service's
 688 // 'downloads' table.
 689 void HistoryService::CreateDownload(
 690     const history::DownloadRow& create_info,
 691     const HistoryService::DownloadCreateCallback& callback) {
 692   DCHECK(thread_) << "History service being called after cleanup";
 693   DCHECK(thread_checker_.CalledOnValidThread());
 694   PostTaskAndReplyWithResult(
 695       thread_->message_loop_proxy().get(),
 696       FROM_HERE,
 697       base::Bind(
 698           &HistoryBackend::CreateDownload, history_backend_.get(), create_info),
 699       callback);
 700 }
 701
 702 void HistoryService::GetNextDownloadId(
 703     const content::DownloadIdCallback& callback) {
 704   DCHECK(thread_) << "History service being called after cleanup";
 705   DCHECK(thread_checker_.CalledOnValidThread());
 706   PostTaskAndReplyWithResult(
 707       thread_->message_loop_proxy().get(),
 708       FROM_HERE,
 709       base::Bind(&HistoryBackend::GetNextDownloadId, history_backend_.get()),
 710       callback);
 711 }
 712
 713 // Handle queries for a list of all downloads in the history database's
 714 // 'downloads' table.
 715 void HistoryService::QueryDownloads(
 716     const DownloadQueryCallback& callback) {
 717   DCHECK(thread_) << "History service being called after cleanup";
 718   DCHECK(thread_checker_.CalledOnValidThread());
 719   std::vector<history::DownloadRow>* rows =
 720     new std::vector<history::DownloadRow>();
 721   scoped_ptr<std::vector<history::DownloadRow> > scoped_rows(rows);
 722   // Beware! The first Bind() does not simply |scoped_rows.get()| because
 723   // base::Passed(&scoped_rows) nullifies |scoped_rows|, and compilers do not
 724   // guarantee that the first Bind's arguments are evaluated before the second
 725   // Bind's arguments.
 726   thread_->message_loop_proxy()->PostTaskAndReply(
 727       FROM_HERE,
 728       base::Bind(&HistoryBackend::QueryDownloads, history_backend_.get(), rows),
 729       base::Bind(callback, base::Passed(&scoped_rows)));
 730 }
 731
 732 // Handle updates for a particular download. This is a 'fire and forget'
 733 // operation, so we don't need to be called back.
 734 void HistoryService::UpdateDownload(const history::DownloadRow& data) {
 735   DCHECK(thread_) << "History service being called after cleanup";
 736   DCHECK(thread_checker_.CalledOnValidThread());
 737   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownload, data);
 738 }
 739
 740 void HistoryService::RemoveDownloads(const std::set<uint32>& ids) {
 741   DCHECK(thread_) << "History service being called after cleanup";
 742   DCHECK(thread_checker_.CalledOnValidThread());
 743   ScheduleAndForget(PRIORITY_NORMAL,
 744                     &HistoryBackend::RemoveDownloads, ids);
 745 }
 746
 747 base::CancelableTaskTracker::TaskId HistoryService::QueryHistory(
 748     const base::string16& text_query,
 749     const history::QueryOptions& options,
 750     const QueryHistoryCallback& callback,
 751     base::CancelableTaskTracker* tracker) {
 752   DCHECK(thread_) << "History service being called after cleanup";
 753   DCHECK(thread_checker_.CalledOnValidThread());
 754   history::QueryResults* query_results = new history::QueryResults();
 755   return tracker->PostTaskAndReply(
 756       thread_->message_loop_proxy().get(),
 757       FROM_HERE,
 758       base::Bind(&HistoryBackend::QueryHistory,
 759                  history_backend_.get(),
 760                  text_query,
 761                  options,
 762                  base::Unretained(query_results)),
 763       base::Bind(callback, base::Owned(query_results)));
 764 }
 765
 766 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsFrom(
 767     const GURL& from_url,
 768     const QueryRedirectsCallback& callback,
 769     base::CancelableTaskTracker* tracker) {
 770   DCHECK(thread_) << "History service being called after cleanup";
 771   DCHECK(thread_checker_.CalledOnValidThread());
 772   history::RedirectList* result = new history::RedirectList();
 773   return tracker->PostTaskAndReply(
 774       thread_->message_loop_proxy().get(),
 775       FROM_HERE,
 776       base::Bind(&HistoryBackend::QueryRedirectsFrom,
 777                  history_backend_.get(),
 778                  from_url,
 779                  base::Unretained(result)),
 780       base::Bind(callback, base::Owned(result)));
 781 }
 782
 783 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsTo(
 784     const GURL& to_url,
 785     const QueryRedirectsCallback& callback,
 786     base::CancelableTaskTracker* tracker) {
 787   DCHECK(thread_) << "History service being called after cleanup";
 788   DCHECK(thread_checker_.CalledOnValidThread());
 789   history::RedirectList* result = new history::RedirectList();
 790   return tracker->PostTaskAndReply(thread_->message_loop_proxy().get(),
 791                                    FROM_HERE,
 792                                    base::Bind(&HistoryBackend::QueryRedirectsTo,
 793                                               history_backend_.get(),
 794                                               to_url,
 795                                               base::Unretained(result)),
 796                                    base::Bind(callback, base::Owned(result)));
 797 }
 798
 799 base::CancelableTaskTracker::TaskId HistoryService::GetVisibleVisitCountToHost(
 800     const GURL& url,
 801     const GetVisibleVisitCountToHostCallback& callback,
 802     base::CancelableTaskTracker* tracker) {
 803   DCHECK(thread_) << "History service being called after cleanup";
 804   DCHECK(thread_checker_.CalledOnValidThread());
 805   history::VisibleVisitCountToHostResult* result =
 806       new history::VisibleVisitCountToHostResult();
 807   return tracker->PostTaskAndReply(
 808       thread_->message_loop_proxy().get(),
 809       FROM_HERE,
 810       base::Bind(&HistoryBackend::GetVisibleVisitCountToHost,
 811                  history_backend_.get(),
 812                  url,
 813                  base::Unretained(result)),
 814       base::Bind(&RunWithVisibleVisitCountToHostResult,
 815                  callback,
 816                  base::Owned(result)));
 817 }
 818
 819 base::CancelableTaskTracker::TaskId HistoryService::QueryMostVisitedURLs(
 820     int result_count,
 821     int days_back,
 822     const QueryMostVisitedURLsCallback& callback,
 823     base::CancelableTaskTracker* tracker) {
 824   DCHECK(thread_) << "History service being called after cleanup";
 825   DCHECK(thread_checker_.CalledOnValidThread());
 826   history::MostVisitedURLList* result = new history::MostVisitedURLList();
 827   return tracker->PostTaskAndReply(
 828       thread_->message_loop_proxy().get(),
 829       FROM_HERE,
 830       base::Bind(&HistoryBackend::QueryMostVisitedURLs,
 831                  history_backend_.get(),
 832                  result_count,
 833                  days_back,
 834                  base::Unretained(result)),
 835       base::Bind(callback, base::Owned(result)));
 836 }
 837
 838 base::CancelableTaskTracker::TaskId HistoryService::QueryFilteredURLs(
 839     int result_count,
 840     const history::VisitFilter& filter,
 841     bool extended_info,
 842     const QueryFilteredURLsCallback& callback,
 843     base::CancelableTaskTracker* tracker) {
 844   DCHECK(thread_) << "History service being called after cleanup";
 845   DCHECK(thread_checker_.CalledOnValidThread());
 846   history::FilteredURLList* result = new history::FilteredURLList();
 847   return tracker->PostTaskAndReply(
 848       thread_->message_loop_proxy().get(),
 849       FROM_HERE,
 850       base::Bind(&HistoryBackend::QueryFilteredURLs,
 851                  history_backend_.get(),
 852                  result_count,
 853                  filter,
 854                  extended_info,
 855                  base::Unretained(result)),
 856       base::Bind(callback, base::Owned(result)));
 857 }
 858
 859 void HistoryService::Cleanup() {
 860   DCHECK(thread_checker_.CalledOnValidThread());
 861   if (!thread_) {
 862     // We've already cleaned up.
 863     return;
 864   }
 865
 866   weak_ptr_factory_.InvalidateWeakPtrs();
 867
 868   // Unload the backend.
 869   if (history_backend_.get()) {
 870     // Get rid of the in-memory backend.
 871     in_memory_backend_.reset();
 872
 873     // Give the InMemoryURLIndex a chance to shutdown.
 874     // NOTE: In tests, there may be no index.
 875     if (in_memory_url_index_)
 876       in_memory_url_index_->ShutDown();
 877
 878     // The backend's destructor must run on the history thread since it is not
 879     // threadsafe. So this thread must not be the last thread holding a
 880     // reference to the backend, or a crash could happen.
 881     //
 882     // We have a reference to the history backend. There is also an extra
 883     // reference held by our delegate installed in the backend, which
 884     // HistoryBackend::Closing will release. This means if we scheduled a call
 885     // to HistoryBackend::Closing and *then* released our backend reference,
 886     // there will be a race between us and the backend's Closing function to see
 887     // who is the last holder of a reference. If the backend thread's Closing
 888     // manages to run before we release our backend refptr, the last reference
 889     // will be held by this thread and the destructor will be called from here.
 890     //
 891     // Therefore, we create a closure to run the Closing operation first. This
 892     // holds a reference to the backend. Then we release our reference, then we
 893     // schedule the task to run. After the task runs, it will delete its
 894     // reference from the history thread, ensuring everything works properly.
 895     //
 896     // TODO(ajwong): Cleanup HistoryBackend lifetime issues.
 897     //     See http://crbug.com/99767.
 898     history_backend_->AddRef();
 899     base::Closure closing_task =
 900         base::Bind(&HistoryBackend::Closing, history_backend_.get());
 901     ScheduleTask(PRIORITY_NORMAL, closing_task);
 902     closing_task.Reset();
 903     HistoryBackend* raw_ptr = history_backend_.get();
 904     history_backend_ = NULL;
 905     thread_->message_loop()->ReleaseSoon(FROM_HERE, raw_ptr);
 906   }
 907
 908   // Delete the thread, which joins with the background thread. We defensively
 909   // NULL the pointer before deleting it in case somebody tries to use it
 910   // during shutdown, but this shouldn't happen.
 911   base::Thread* thread = thread_;
 912   thread_ = NULL;
 913   delete thread;
 914 }
 915
 916 void HistoryService::Observe(int type,
 917                              const content::NotificationSource& source,
 918                              const content::NotificationDetails& details) {
 919   DCHECK(thread_checker_.CalledOnValidThread());
 920   if (!thread_)
 921     return;
 922
 923   switch (type) {
 924     case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
 925       // Update the visited link system for deleted URLs. We will update the
 926       // visited link system for added URLs as soon as we get the add
 927       // notification (we don't have to wait for the backend, which allows us to
 928       // be faster to update the state).
 929       //
 930       // For deleted URLs, we don't typically know what will be deleted since
 931       // delete notifications are by time. We would also like to be more
 932       // respectful of privacy and never tell the user something is gone when it
 933       // isn't. Therefore, we update the delete URLs after the fact.
 934       if (visitedlink_master_) {
 935         content::Details<history::URLsDeletedDetails> deleted_details(details);
 936
 937         if (deleted_details->all_history) {
 938           visitedlink_master_->DeleteAllURLs();
 939         } else {
 940           URLIteratorFromURLRows iterator(deleted_details->rows);
 941           visitedlink_master_->DeleteURLs(&iterator);
 942         }
 943       }
 944       break;
 945     }
 946
 947     default:
 948       NOTREACHED();
 949   }
 950 }
 951
 952 void HistoryService::RebuildTable(
 953     const scoped_refptr<URLEnumerator>& enumerator) {
 954   DCHECK(thread_) << "History service being called after cleanup";
 955   DCHECK(thread_checker_.CalledOnValidThread());
 956   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
 957 }
 958
 959 bool HistoryService::Init(const base::FilePath& history_dir, bool no_db) {
 960   DCHECK(thread_) << "History service being called after cleanup";
 961   DCHECK(thread_checker_.CalledOnValidThread());
 962   base::Thread::Options options;
 963   options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 964   if (!thread_->StartWithOptions(options)) {
 965     Cleanup();
 966     return false;
 967   }
 968
 969   history_dir_ = history_dir;
 970   no_db_ = no_db;
 971
 972   if (profile_) {
 973     std::string languages =
 974         profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
 975     in_memory_url_index_.reset(new history::InMemoryURLIndex(
 976         profile_, history_dir_, languages, history_client_));
 977     in_memory_url_index_->Init();
 978   }
 979
 980   // Create the history backend.
 981   scoped_refptr<HistoryBackend> backend(
 982       new HistoryBackend(history_dir_,
 983                          new BackendDelegate(
 984                              weak_ptr_factory_.GetWeakPtr(),
 985                              base::ThreadTaskRunnerHandle::Get(),
 986                              profile_),
 987                          history_client_));
 988   history_backend_.swap(backend);
 989
 990   // There may not be a profile when unit testing.
 991   std::string languages;
 992   if (profile_) {
 993     PrefService* prefs = profile_->GetPrefs();
 994     languages = prefs->GetString(prefs::kAcceptLanguages);
 995   }
 996   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_);
 997
 998   if (visitedlink_master_) {
 999     bool result = visitedlink_master_->Init();
1000     DCHECK(result);
1001   }
1002
1003   return true;
1004 }
1005
1006 void HistoryService::ScheduleAutocomplete(const base::Callback<
1007     void(history::HistoryBackend*, history::URLDatabase*)>& callback) {
1008   DCHECK(thread_checker_.CalledOnValidThread());
1009   ScheduleAndForget(
1010       PRIORITY_UI, &HistoryBackend::ScheduleAutocomplete, callback);
1011 }
1012
1013 void HistoryService::ScheduleTask(SchedulePriority priority,
1014                                   const base::Closure& task) {
1015   DCHECK(thread_checker_.CalledOnValidThread());
1016   CHECK(thread_);
1017   CHECK(thread_->message_loop());
1018   // TODO(brettw): Do prioritization.
1019   thread_->message_loop()->PostTask(FROM_HERE, task);
1020 }
1021
1022 // static
1023 bool HistoryService::CanAddURL(const GURL& url) {
1024   if (!url.is_valid())
1025     return false;
1026
1027   // TODO: We should allow kChromeUIScheme URLs if they have been explicitly
1028   // typed.  Right now, however, these are marked as typed even when triggered
1029   // by a shortcut or menu action.
1030   if (url.SchemeIs(url::kJavaScriptScheme) ||
1031       url.SchemeIs(content::kChromeDevToolsScheme) ||
1032       url.SchemeIs(content::kChromeUIScheme) ||
1033       url.SchemeIs(content::kViewSourceScheme) ||
1034       url.SchemeIs(chrome::kChromeNativeScheme) ||
1035       url.SchemeIs(chrome::kChromeSearchScheme) ||
1036       url.SchemeIs(dom_distiller::kDomDistillerScheme))
1037     return false;
1038
1039   // Allow all about: and chrome: URLs except about:blank, since the user may
1040   // like to see "chrome://memory/", etc. in their history and autocomplete.
1041   if (url == GURL(url::kAboutBlankURL))
1042     return false;
1043
1044   return true;
1045 }
1046
1047 base::WeakPtr<HistoryService> HistoryService::AsWeakPtr() {
1048   DCHECK(thread_checker_.CalledOnValidThread());
1049   return weak_ptr_factory_.GetWeakPtr();
1050 }
1051
1052 syncer::SyncMergeResult HistoryService::MergeDataAndStartSyncing(
1053     syncer::ModelType type,
1054     const syncer::SyncDataList& initial_sync_data,
1055     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
1056     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
1057   DCHECK(thread_checker_.CalledOnValidThread());
1058   DCHECK_EQ(type, syncer::HISTORY_DELETE_DIRECTIVES);
1059   delete_directive_handler_.Start(this, initial_sync_data,
1060                                   sync_processor.Pass());
1061   return syncer::SyncMergeResult(type);
1062 }
1063
1064 void HistoryService::StopSyncing(syncer::ModelType type) {
1065   DCHECK(thread_checker_.CalledOnValidThread());
1066   DCHECK_EQ(type, syncer::HISTORY_DELETE_DIRECTIVES);
1067   delete_directive_handler_.Stop();
1068 }
1069
1070 syncer::SyncDataList HistoryService::GetAllSyncData(
1071     syncer::ModelType type) const {
1072   DCHECK(thread_checker_.CalledOnValidThread());
1073   DCHECK_EQ(type, syncer::HISTORY_DELETE_DIRECTIVES);
1074   // TODO(akalin): Keep track of existing delete directives.
1075   return syncer::SyncDataList();
1076 }
1077
1078 syncer::SyncError HistoryService::ProcessSyncChanges(
1079     const tracked_objects::Location& from_here,
1080     const syncer::SyncChangeList& change_list) {
1081   delete_directive_handler_.ProcessSyncChanges(this, change_list);
1082   return syncer::SyncError();
1083 }
1084
1085 syncer::SyncError HistoryService::ProcessLocalDeleteDirective(
1086     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
1087   DCHECK(thread_checker_.CalledOnValidThread());
1088   return delete_directive_handler_.ProcessLocalDeleteDirective(
1089       delete_directive);
1090 }
1091
1092 void HistoryService::SetInMemoryBackend(
1093     scoped_ptr<history::InMemoryHistoryBackend> mem_backend) {
1094   DCHECK(thread_checker_.CalledOnValidThread());
1095   DCHECK(!in_memory_backend_) << "Setting mem DB twice";
1096   in_memory_backend_.reset(mem_backend.release());
1097
1098   // The database requires additional initialization once we own it.
1099   in_memory_backend_->AttachToHistoryService(profile_);
1100 }
1101
1102 void HistoryService::NotifyProfileError(sql::InitStatus init_status) {
1103   DCHECK(thread_checker_.CalledOnValidThread());
1104   if (history_client_)
1105     history_client_->NotifyProfileError(init_status);
1106 }
1107
1108 void HistoryService::DeleteURL(const GURL& url) {
1109   DCHECK(thread_) << "History service being called after cleanup";
1110   DCHECK(thread_checker_.CalledOnValidThread());
1111   // We will update the visited links when we observe the delete notifications.
1112   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURL, url);
1113 }
1114
1115 void HistoryService::DeleteURLsForTest(const std::vector<GURL>& urls) {
1116   DCHECK(thread_) << "History service being called after cleanup";
1117   DCHECK(thread_checker_.CalledOnValidThread());
1118   // We will update the visited links when we observe the delete
1119   // notifications.
1120   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURLs, urls);
1121 }
1122
1123 void HistoryService::ExpireHistoryBetween(
1124     const std::set<GURL>& restrict_urls,
1125     Time begin_time,
1126     Time end_time,
1127     const base::Closure& callback,
1128     base::CancelableTaskTracker* tracker) {
1129   DCHECK(thread_) << "History service being called after cleanup";
1130   DCHECK(thread_checker_.CalledOnValidThread());
1131   tracker->PostTaskAndReply(thread_->message_loop_proxy().get(),
1132                             FROM_HERE,
1133                             base::Bind(&HistoryBackend::ExpireHistoryBetween,
1134                                        history_backend_,
1135                                        restrict_urls,
1136                                        begin_time,
1137                                        end_time),
1138                             callback);
1139 }
1140
1141 void HistoryService::ExpireHistory(
1142     const std::vector<history::ExpireHistoryArgs>& expire_list,
1143     const base::Closure& callback,
1144     base::CancelableTaskTracker* tracker) {
1145   DCHECK(thread_) << "History service being called after cleanup";
1146   DCHECK(thread_checker_.CalledOnValidThread());
1147   tracker->PostTaskAndReply(
1148       thread_->message_loop_proxy().get(),
1149       FROM_HERE,
1150       base::Bind(&HistoryBackend::ExpireHistory, history_backend_, expire_list),
1151       callback);
1152 }
1153
1154 void HistoryService::ExpireLocalAndRemoteHistoryBetween(
1155     const std::set<GURL>& restrict_urls,
1156     Time begin_time,
1157     Time end_time,
1158     const base::Closure& callback,
1159     base::CancelableTaskTracker* tracker) {
1160   // TODO(dubroy): This should be factored out into a separate class that
1161   // dispatches deletions to the proper places.
1162
1163   history::WebHistoryService* web_history =
1164       WebHistoryServiceFactory::GetForProfile(profile_);
1165   if (web_history) {
1166     // TODO(dubroy): This API does not yet support deletion of specific URLs.
1167     DCHECK(restrict_urls.empty());
1168
1169     delete_directive_handler_.CreateDeleteDirectives(
1170         std::set<int64>(), begin_time, end_time);
1171
1172     // Attempt online deletion from the history server, but ignore the result.
1173     // Deletion directives ensure that the results will eventually be deleted.
1174     //
1175     // TODO(davidben): |callback| should not run until this operation completes
1176     // too.
1177     web_history->ExpireHistoryBetween(
1178         restrict_urls, begin_time, end_time,
1179         base::Bind(&ExpireWebHistoryComplete));
1180   }
1181   ExpireHistoryBetween(restrict_urls, begin_time, end_time, callback, tracker);
1182 }
1183
1184 void HistoryService::BroadcastNotificationsHelper(
1185     int type,
1186     scoped_ptr<history::HistoryDetails> details) {
1187   DCHECK(thread_checker_.CalledOnValidThread());
1188   // TODO(evanm): this is currently necessitated by generate_profile, which
1189   // runs without a browser process. generate_profile should really create
1190   // a browser process, at which point this check can then be nuked.
1191   if (!g_browser_process)
1192     return;
1193
1194   if (!thread_)
1195     return;
1196
1197   // The source of all of our notifications is the profile. Note that this
1198   // pointer is NULL in unit tests.
1199   content::Source<Profile> source(profile_);
1200
1201   // The details object just contains the pointer to the object that the
1202   // backend has allocated for us. The receiver of the notification will cast
1203   // this to the proper type.
1204   content::Details<history::HistoryDetails> det(details.get());
1205
1206   content::NotificationService::current()->Notify(type, source, det);
1207 }
1208
1209 void HistoryService::OnDBLoaded() {
1210   DCHECK(thread_checker_.CalledOnValidThread());
1211   backend_loaded_ = true;
1212   content::NotificationService::current()->Notify(
1213       chrome::NOTIFICATION_HISTORY_LOADED,
1214       content::Source<Profile>(profile_),
1215       content::Details<HistoryService>(this));
1216 }
1217
1218 bool HistoryService::GetRowForURL(const GURL& url, history::URLRow* url_row) {
1219   DCHECK(thread_checker_.CalledOnValidThread());
1220   history::URLDatabase* db = InMemoryDatabase();
1221   return db && (db->GetRowForURL(url, url_row) != 0);
1222 }
1223
1224 void HistoryService::AddVisitDatabaseObserver(
1225     history::VisitDatabaseObserver* observer) {
1226   DCHECK(thread_checker_.CalledOnValidThread());
1227   visit_database_observers_.AddObserver(observer);
1228 }
1229
1230 void HistoryService::RemoveVisitDatabaseObserver(
1231     history::VisitDatabaseObserver* observer) {
1232   DCHECK(thread_checker_.CalledOnValidThread());
1233   visit_database_observers_.RemoveObserver(observer);
1234 }
1235
1236 void HistoryService::NotifyVisitDBObserversOnAddVisit(
1237     const history::BriefVisitInfo& info) {
1238   DCHECK(thread_checker_.CalledOnValidThread());
1239   FOR_EACH_OBSERVER(history::VisitDatabaseObserver, visit_database_observers_,
1240                     OnAddVisit(info));
1241 }
1242
1243 scoped_ptr<base::CallbackList<void(const std::set<GURL>&)>::Subscription>
1244 HistoryService::AddFaviconChangedCallback(
1245     const HistoryService::OnFaviconChangedCallback& callback) {
1246   DCHECK(thread_checker_.CalledOnValidThread());
1247   return favicon_changed_callback_list_.Add(callback);
1248 }
1249
1250 void HistoryService::NotifyFaviconChanged(
1251     const std::set<GURL>& changed_favicons) {
1252   DCHECK(thread_checker_.CalledOnValidThread());
1253   favicon_changed_callback_list_.Notify(changed_favicons);
1254 }