components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/history/core/browser/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
 // -----------                       --------------
 // HistoryService <----------------> HistoryBackend
 //                                   -> HistoryDatabase
 //                                      -> SQLite connection to History
 //                                   -> ThumbnailDatabase
 //                                      -> SQLite connection to Thumbnails
 //                                         (and favicons)
 
 #include "components/history/core/browser/history_service.h"
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_client.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service_observer.h"
@@ skipping 288 matching lines @@
     scoped_ptr<HistoryDBTask> task,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
   base::CancelableTaskTracker::TaskId task_id =
       tracker->NewTrackedTaskId(&is_canceled);
   // Use base::ThreadTaskRunnerHandler::Get() to get a message loop proxy to
   // the current message loop so that we can forward the call to the method
   // HistoryDBTask::DoneRunOnMainThread() in the correct thread.
-  thread_->message_loop_proxy()->PostTask(
+  thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTask,
                             history_backend_.get(), base::Passed(&task),
                             base::ThreadTaskRunnerHandle::Get(), is_canceled));
   return task_id;
 }
 
 void HistoryService::FlushForTest(const base::Closure& flushed) {
-  thread_->message_loop_proxy()->PostTaskAndReply(
+  thread_->task_runner()->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());
   ScheduleTask(
       PRIORITY_NORMAL,
       base::Bind(&HistoryBackend::SetOnBackendDestroyTask,
                  history_backend_.get(), base::MessageLoop::current(), task));
@@ skipping 139 matching lines @@
     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());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetFavicons, history_backend_.get(),
                  icon_urls, icon_types, desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
     const GURL& page_url,
     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());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconsForURL, history_backend_.get(),
                  page_url, icon_types, desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_base::FaviconRawBitmapResult* result =
       new favicon_base::FaviconRawBitmapResult();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetLargestFaviconForURL,
                  history_backend_.get(), page_url, icon_types,
                  minimum_size_in_pixels, result),
       base::Bind(&RunWithFaviconResult, callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
     favicon_base::FaviconID favicon_id,
     int desired_size,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconForID, history_backend_.get(),
                  favicon_id, desired_size, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId
 HistoryService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     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());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
                  history_backend_.get(), page_url, icon_urls, icon_types,
                  desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 void HistoryService::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
@@ skipping 43 matching lines @@
 
 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());
   QueryURLResult* query_url_result = new QueryURLResult();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryURL, history_backend_.get(), url,
                  want_visits, base::Unretained(query_url_result)),
       base::Bind(&RunWithQueryURLResult, callback,
                  base::Owned(query_url_result)));
 }
 
 // Downloads -------------------------------------------------------------------
 
 // Handle creation of a download by creating an entry in the history service's
 // 'downloads' table.
 void HistoryService::CreateDownload(
     const DownloadRow& create_info,
     const HistoryService::DownloadCreateCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  PostTaskAndReplyWithResult(thread_->message_loop_proxy().get(), FROM_HERE,
+  PostTaskAndReplyWithResult(thread_->task_runner().get(), FROM_HERE,
                              base::Bind(&HistoryBackend::CreateDownload,
                                         history_backend_.get(), create_info),
                              callback);
 }
 
 void HistoryService::GetNextDownloadId(const DownloadIdCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetNextDownloadId, history_backend_.get()),
       callback);
 }
 
 // Handle queries for a list of all downloads in the history database's
 // 'downloads' table.
 void HistoryService::QueryDownloads(const DownloadQueryCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<DownloadRow>* rows = new std::vector<DownloadRow>();
   scoped_ptr<std::vector<DownloadRow>> scoped_rows(rows);
   // Beware! The first Bind() does not simply |scoped_rows.get()| because
   // base::Passed(&scoped_rows) nullifies |scoped_rows|, and compilers do not
   // guarantee that the first Bind's arguments are evaluated before the second
   // Bind's arguments.
-  thread_->message_loop_proxy()->PostTaskAndReply(
+  thread_->task_runner()->PostTaskAndReply(
       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 DownloadRow& data) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 10 matching lines @@
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryHistory(
     const base::string16& text_query,
     const QueryOptions& options,
     const QueryHistoryCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   QueryResults* query_results = new QueryResults();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryHistory, history_backend_.get(),
                  text_query, options, base::Unretained(query_results)),
       base::Bind(callback, base::Owned(query_results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsFrom(
     const GURL& from_url,
     const QueryRedirectsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryRedirectsFrom, history_backend_.get(),
                  from_url, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsTo(
     const GURL& to_url,
     const QueryRedirectsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryRedirectsTo, history_backend_.get(),
                  to_url, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetVisibleVisitCountToHost(
     const GURL& url,
     const GetVisibleVisitCountToHostCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   VisibleVisitCountToHostResult* result = new VisibleVisitCountToHostResult();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetVisibleVisitCountToHost,
                  history_backend_.get(), url, base::Unretained(result)),
       base::Bind(&RunWithVisibleVisitCountToHostResult, callback,
                  base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryMostVisitedURLs(
     int result_count,
     int days_back,
     const QueryMostVisitedURLsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   MostVisitedURLList* result = new MostVisitedURLList();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryMostVisitedURLs, history_backend_.get(),
                  result_count, days_back, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryFilteredURLs(
     int result_count,
     const VisitFilter& filter,
     bool extended_info,
     const QueryFilteredURLsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   FilteredURLList* result = new FilteredURLList();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryFilteredURLs, history_backend_.get(),
                  result_count, filter, extended_info, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 void HistoryService::Cleanup() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!thread_) {
     // We've already cleaned up.
     return;
@@ skipping 86 matching lines @@
   ScheduleTask(PRIORITY_UI, base::Bind(&HistoryBackend::ScheduleAutocomplete,
                                        history_backend_.get(), callback));
 }
 
 void HistoryService::ScheduleTask(SchedulePriority priority,
                                   const base::Closure& task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(thread_);
   CHECK(thread_->message_loop());
   // TODO(brettw): Do prioritization.
-  thread_->message_loop()->PostTask(FROM_HERE, task);
+  thread_->task_runner()->PostTask(FROM_HERE, task);
 }
 
 base::WeakPtr<HistoryService> HistoryService::AsWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 syncer::SyncMergeResult HistoryService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
@@ skipping 69 matching lines @@
 
 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());
   tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::ExpireHistoryBetween, history_backend_,
                  restrict_urls, begin_time, end_time),
       callback);
 }
 
 void HistoryService::ExpireHistory(
     const std::vector<ExpireHistoryArgs>& expire_list,
     const base::Closure& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   tracker->PostTaskAndReply(
-      thread_->message_loop_proxy().get(), FROM_HERE,
+      thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::ExpireHistory, history_backend_, expire_list),
       callback);
 }
 
 void HistoryService::ExpireLocalAndRemoteHistoryBetween(
     WebHistoryService* web_history,
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
@@ skipping 112 matching lines @@
   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);
 }
 
 }  // namespace history