Inline ScheduleAndForget implementation in HistoryService

chrome/browser/history/history_service.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 237 matching lines @@
 
 bool HistoryService::BackendLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return backend_loaded_;
 }
 
 void HistoryService::ClearCachedDataForContextID(
     history::ContextID context_id) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::ClearCachedDataForContextID, context_id);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::ClearCachedDataForContextID,
+                          history_backend_.get(), context_id));
 }
 
 history::URLDatabase* HistoryService::InMemoryDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return in_memory_backend_ ? in_memory_backend_->db() : NULL;
 }
 
 bool HistoryService::GetTypedCountForURL(const GURL& url, int* typed_count) {
   DCHECK(thread_checker_.CalledOnValidThread());
   history::URLRow url_row;
@@ skipping 30 matching lines @@
 void HistoryService::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Cleanup();
 }
 
 void HistoryService::SetKeywordSearchTermsForURL(const GURL& url,
                                                  KeywordID keyword_id,
                                                  const base::string16& term) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_UI,
-                    &HistoryBackend::SetKeywordSearchTermsForURL,
-                    url, keyword_id, term);
+  ScheduleTask(PRIORITY_UI,
+               base::Bind(&HistoryBackend::SetKeywordSearchTermsForURL,
+                          history_backend_.get(), url, keyword_id, term));
 }
 
 void HistoryService::DeleteAllSearchTermsForKeyword(KeywordID keyword_id) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (in_memory_backend_)
     in_memory_backend_->DeleteAllSearchTermsForKeyword(keyword_id);
 
-  ScheduleAndForget(PRIORITY_UI,
-                    &HistoryBackend::DeleteAllSearchTermsForKeyword,
-                    keyword_id);
+  ScheduleTask(PRIORITY_UI,
+               base::Bind(&HistoryBackend::DeleteAllSearchTermsForKeyword,
+                          history_backend_.get(), keyword_id));
 }
 
 void HistoryService::DeleteKeywordSearchTermForURL(const GURL& url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::DeleteKeywordSearchTermForURL,
-                    url);
+  ScheduleTask(PRIORITY_UI,
+               base::Bind(&HistoryBackend::DeleteKeywordSearchTermForURL,
+                          history_backend_.get(), url));
 }
 
 void HistoryService::DeleteMatchingURLsForKeyword(KeywordID keyword_id,
                                                   const base::string16& term) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::DeleteMatchingURLsForKeyword,
-                    keyword_id, term);
+  ScheduleTask(PRIORITY_UI,
+               base::Bind(&HistoryBackend::DeleteMatchingURLsForKeyword,
+                          history_backend_.get(), keyword_id, term));
 }
 
 void HistoryService::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::URLsNoLongerBookmarked,
-                    urls);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::URLsNoLongerBookmarked,
+                          history_backend_.get(), urls));
 }
 
 void HistoryService::AddObserver(history::HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void HistoryService::RemoveObserver(history::HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
@@ skipping 18 matching lines @@
 }
 
 void HistoryService::FlushForTest(const base::Closure& flushed) {
   thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), flushed);
 }
 
 void HistoryService::SetOnBackendDestroyTask(const base::Closure& task) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetOnBackendDestroyTask,
-                    base::MessageLoop::current(), task);
+  ScheduleTask(
+      PRIORITY_NORMAL,
+      base::Bind(&HistoryBackend::SetOnBackendDestroyTask,
+                 history_backend_.get(), base::MessageLoop::current(), task));
 }
 
 void HistoryService::AddPage(const GURL& url,
                              Time time,
                              history::ContextID context_id,
                              int nav_entry_id,
                              const GURL& referrer,
                              const history::RedirectList& redirects,
                              ui::PageTransition transition,
                              history::VisitSource visit_source,
@@ skipping 36 matching lines @@
       DCHECK_EQ(add_page_args.url,
                 add_page_args.redirects[add_page_args.redirects.size() - 1]);
 
       // We need the !redirects.empty() condition above since size_t is unsigned
       // and will wrap around when we subtract one from a 0 size.
       for (size_t i = 0; i < add_page_args.redirects.size() - 1; i++)
         visitedlink_master_->AddURL(add_page_args.redirects[i]);
     }
   }
 
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::AddPage, add_page_args);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::AddPage, history_backend_.get(),
+                          add_page_args));
 }
 
 void HistoryService::AddPageNoVisitForBookmark(const GURL& url,
                                                const base::string16& title) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(url))
     return;
 
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::AddPageNoVisitForBookmark, url, title);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::AddPageNoVisitForBookmark,
+                          history_backend_.get(), url, title));
 }
 
 void HistoryService::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetPageTitle, url, title);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::SetPageTitle,
+                                           history_backend_.get(), url, title));
 }
 
 void HistoryService::UpdateWithPageEndTime(history::ContextID context_id,
                                            int nav_entry_id,
                                            const GURL& url,
                                            Time end_ts) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateWithPageEndTime,
-                    context_id, nav_entry_id, url, end_ts);
+  ScheduleTask(
+      PRIORITY_NORMAL,
+      base::Bind(&HistoryBackend::UpdateWithPageEndTime, history_backend_.get(),
+                 context_id, nav_entry_id, url, end_ts));
 }
 
 void HistoryService::AddPageWithDetails(const GURL& url,
                                         const base::string16& title,
                                         int visit_count,
                                         int typed_count,
                                         Time last_visit,
                                         bool hidden,
                                         history::VisitSource visit_source) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // Filter out unwanted URLs.
   if (!CanAddURL(url))
     return;
 
   // Add to the visited links system.
   if (visitedlink_master_)
     visitedlink_master_->AddURL(url);
 
   history::URLRow row(url);
   row.set_title(title);
   row.set_visit_count(visit_count);
   row.set_typed_count(typed_count);
   row.set_last_visit(last_visit);
   row.set_hidden(hidden);
 
   history::URLRows rows;
   rows.push_back(row);
 
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::AddPagesWithDetails, rows, visit_source);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::AddPagesWithDetails,
+                          history_backend_.get(), rows, visit_source));
 }
 
 void HistoryService::AddPagesWithDetails(const history::URLRows& info,
                                          history::VisitSource visit_source) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // Add to the visited links system.
   if (visitedlink_master_) {
     std::vector<GURL> urls;
     urls.reserve(info.size());
     for (history::URLRows::const_iterator i = info.begin(); i != info.end();
          ++i)
       urls.push_back(i->url());
 
     visitedlink_master_->AddURLs(urls);
   }
 
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::AddPagesWithDetails, info, visit_source);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::AddPagesWithDetails,
+                          history_backend_.get(), info, visit_source));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 104 matching lines @@
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(page_url))
     return;
 
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::MergeFavicon, page_url,
-                    icon_url, icon_type, bitmap_data, pixel_size);
+  ScheduleTask(
+      PRIORITY_NORMAL,
+      base::Bind(&HistoryBackend::MergeFavicon, history_backend_.get(),
+                 page_url, icon_url, icon_type, bitmap_data, pixel_size));
 }
 
 void HistoryService::SetFavicons(
     const GURL& page_url,
     favicon_base::IconType icon_type,
     const GURL& icon_url,
     const std::vector<SkBitmap>& bitmaps) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(page_url))
     return;
 
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetFavicons, page_url,
-      icon_type, icon_url, bitmaps);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::SetFavicons, history_backend_.get(),
+                          page_url, icon_type, icon_url, bitmaps));
 }
 
 void HistoryService::SetFaviconsOutOfDateForPage(const GURL& page_url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::SetFaviconsOutOfDateForPage, page_url);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::SetFaviconsOutOfDateForPage,
+                          history_backend_.get(), page_url));
 }
 
 void HistoryService::CloneFavicons(const GURL& old_page_url,
                                    const GURL& new_page_url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::CloneFavicons,
-                    old_page_url, new_page_url);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::CloneFavicons,
+                          history_backend_.get(), old_page_url, new_page_url));
 }
 
 void HistoryService::SetImportedFavicons(
     const std::vector<ImportedFaviconUsage>& favicon_usage) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::SetImportedFavicons, favicon_usage);
+  ScheduleTask(PRIORITY_NORMAL,
+               base::Bind(&HistoryBackend::SetImportedFavicons,
+                          history_backend_.get(), favicon_usage));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryURL(
     const GURL& url,
     bool want_visits,
     const QueryURLCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   history::QueryURLResult* query_url_result = new history::QueryURLResult();
@@ skipping 54 matching lines @@
       FROM_HERE,
       base::Bind(&HistoryBackend::QueryDownloads, history_backend_.get(), rows),
       base::Bind(callback, base::Passed(&scoped_rows)));
 }
 
 // Handle updates for a particular download. This is a 'fire and forget'
 // operation, so we don't need to be called back.
 void HistoryService::UpdateDownload(const history::DownloadRow& data) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownload, data);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::UpdateDownload,
+                                           history_backend_.get(), data));
 }
 
 void HistoryService::RemoveDownloads(const std::set<uint32>& ids) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::RemoveDownloads, ids);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::RemoveDownloads,
+                                           history_backend_.get(), ids));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryHistory(
     const base::string16& text_query,
     const history::QueryOptions& options,
     const QueryHistoryCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   history::QueryResults* query_results = new history::QueryResults();
@@ skipping 157 matching lines @@
   // during shutdown, but this shouldn't happen.
   base::Thread* thread = thread_;
   thread_ = NULL;
   delete thread;
 }
 
 void HistoryService::RebuildTable(
     const scoped_refptr<URLEnumerator>& enumerator) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::IterateURLs,
+                                           history_backend_.get(), enumerator));
 }
 
 bool HistoryService::Init(
     bool no_db,
     const history::HistoryDatabaseParams& history_database_params) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::Thread::Options options;
   options.timer_slack = base::TIMER_SLACK_MAXIMUM;
   if (!thread_->StartWithOptions(options)) {
@@ skipping 19 matching lines @@
       history_client_));
   history_backend_.swap(backend);
 
   // There may not be a profile when unit testing.
   std::string languages;
   if (profile_) {
     PrefService* prefs = profile_->GetPrefs();
     languages = prefs->GetString(prefs::kAcceptLanguages);
   }
 
-  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_,
-                    history_database_params);
+  ScheduleTask(PRIORITY_UI,
+               base::Bind(&HistoryBackend::Init, history_backend_.get(),
+                          languages, no_db_, history_database_params));
 
   if (visitedlink_master_) {
     bool result = visitedlink_master_->Init();
     DCHECK(result);
   }
 
   return true;
 }
 
 void HistoryService::ScheduleAutocomplete(const base::Callback<
     void(history::HistoryBackend*, history::URLDatabase*)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(
-      PRIORITY_UI, &HistoryBackend::ScheduleAutocomplete, callback);
+  ScheduleTask(PRIORITY_UI, base::Bind(&HistoryBackend::ScheduleAutocomplete,
+                                       history_backend_.get(), callback));
 }
 
 void HistoryService::ScheduleTask(SchedulePriority priority,
                                   const base::Closure& task) {
+  DCHECK(thread_) << "History service being called after cleanup";

[droger, 2015/01/30 16:40:37]

Not sure if this CHECK should be changed in DCHECK.

[sdefresne, 2015/01/30 21:17:01]

Changed back to CHECK, thank you.

   DCHECK(thread_checker_.CalledOnValidThread());
-  CHECK(thread_);
-  CHECK(thread_->message_loop());
+  DCHECK(thread_->message_loop());
   // TODO(brettw): Do prioritization.
   thread_->message_loop()->PostTask(FROM_HERE, task);
 }
 
 // static
 bool HistoryService::CanAddURL(const GURL& url) {
   if (!url.is_valid())
     return false;
 
   // TODO: We should allow kChromeUIScheme URLs if they have been explicitly
@@ skipping 74 matching lines @@
 void HistoryService::NotifyProfileError(sql::InitStatus init_status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_)
     history_client_->NotifyProfileError(init_status);
 }
 
 void HistoryService::DeleteURL(const GURL& url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete notifications.
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURL, url);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURL,
+                                           history_backend_.get(), url));
 }
 
 void HistoryService::DeleteURLsForTest(const std::vector<GURL>& urls) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete
   // notifications.
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURLs, urls);
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURLs,
+                                           history_backend_.get(), urls));
 }
 
 void HistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 148 matching lines @@
     const HistoryService::OnFaviconChangedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return favicon_changed_callback_list_.Add(callback);
 }
 
 void HistoryService::NotifyFaviconChanged(
     const std::set<GURL>& changed_favicons) {
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_changed_callback_list_.Notify(changed_favicons);
 }