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