Redirect HistoryService thread to TaskScheduler via a field trial.

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
@@ skipping 10 matching lines @@
 #include <utility>
 
 #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/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_client.h"
 #include "components/history/core/browser/history_database_params.h"
@@ skipping 14 matching lines @@
 #include "base/critical_closure.h"
 #endif
 
 using base::Time;
 
 namespace history {
 namespace {
 
 static const char* kHistoryThreadName = "Chrome_HistoryThread";
 
+// Whether HistoryBackend tasks should run on a TaskScheduler sequence rather
+// than on a dedicated thread.
+// TODO(fdoray): Remove once the HistoryService redirection experiment
+// concludes. https://crbug.com/661143
+bool g_redirected_to_task_scheduler = false;
+
+// Whether an HistoryService has been instantiated in the current process.
+// TODO(fdoray): Remove once the HistoryService redirection experiment
+// concludes. https://crbug.com/661143
+bool g_instantiated_history_service = false;
+
 void RunWithFaviconResults(
     const favicon_base::FaviconResultsCallback& callback,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   TRACE_EVENT0("browser", "RunWithFaviconResults");
   callback.Run(*bitmap_results);
 }
 
 void RunWithFaviconResult(
     const favicon_base::FaviconRawBitmapCallback& callback,
     favicon_base::FaviconRawBitmapResult* bitmap_result) {
@@ skipping 100 matching lines @@
   void DBLoaded() override {
     service_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HistoryService::OnDBLoaded, history_service_));
   }
 
  private:
   const base::WeakPtr<HistoryService> history_service_;
   const scoped_refptr<base::SequencedTaskRunner> service_task_runner_;
 };
 
-// The history thread is intentionally not a BrowserThread because the
-// sync integration unit tests depend on being able to create more than one
-// history thread.
-HistoryService::HistoryService()
-    : thread_(new base::Thread(kHistoryThreadName)),
-      history_client_(nullptr),
-      backend_loaded_(false),
-      weak_ptr_factory_(this) {
-}
+HistoryService::HistoryService() : HistoryService(nullptr, nullptr) {}
 
 HistoryService::HistoryService(std::unique_ptr<HistoryClient> history_client,
                                std::unique_ptr<VisitDelegate> visit_delegate)
-    : thread_(new base::Thread(kHistoryThreadName)),
+    : thread_(g_redirected_to_task_scheduler
+                  ? nullptr
+                  : new base::Thread(kHistoryThreadName)),
       history_client_(std::move(history_client)),
       visit_delegate_(std::move(visit_delegate)),
       backend_loaded_(false),
-      weak_ptr_factory_(this) {}
+      weak_ptr_factory_(this) {
+  g_instantiated_history_service = true;
+}
 
 HistoryService::~HistoryService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Shutdown the backend. This does nothing if Cleanup was already invoked.
   Cleanup();
 }
 
+void HistoryService::RedirectToTaskSchedulerForProcess() {
+  DCHECK(!g_instantiated_history_service);
+  DCHECK(!g_redirected_to_task_scheduler);
+  g_redirected_to_task_scheduler = true;
+}
+
 bool HistoryService::BackendLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return backend_loaded_;
 }
 
 #if defined(OS_IOS)
 void HistoryService::HandleBackgrounding() {
-  if (!thread_ || !history_backend_.get())
+  if (!backend_task_runner_ || !history_backend_.get())
     return;
 
   ScheduleTask(PRIORITY_NORMAL,
                base::MakeCriticalClosure(base::Bind(
                    &HistoryBackend::PersistState, history_backend_.get())));
 }
 #endif
 
 void HistoryService::ClearCachedDataForContextID(ContextID context_id) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::ClearCachedDataForContextID,
                           history_backend_, context_id));
 }
 
 URLDatabase* HistoryService::InMemoryDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return in_memory_backend_ ? in_memory_backend_->db() : nullptr;
 }
 
 TypedUrlSyncableService* HistoryService::GetTypedUrlSyncableService() const {
   return history_backend_->GetTypedUrlSyncableService();
 }
 
 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::SetKeywordSearchTermsForURL,
                           history_backend_, url, keyword_id, term));
 }
 
 void HistoryService::DeleteAllSearchTermsForKeyword(KeywordID keyword_id) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (in_memory_backend_)
     in_memory_backend_->DeleteAllSearchTermsForKeyword(keyword_id);
 
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteAllSearchTermsForKeyword,
                           history_backend_, keyword_id));
 }
 
 void HistoryService::DeleteKeywordSearchTermForURL(const GURL& url) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteKeywordSearchTermForURL,
                           history_backend_, url));
 }
 
 void HistoryService::DeleteMatchingURLsForKeyword(KeywordID keyword_id,
                                                   const base::string16& term) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteMatchingURLsForKeyword,
                           history_backend_, keyword_id, term));
 }
 
 void HistoryService::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::URLsNoLongerBookmarked,
                           history_backend_, urls));
 }
 
 void HistoryService::AddObserver(HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void HistoryService::RemoveObserver(HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::ScheduleDBTask(
     std::unique_ptr<HistoryDBTask> task,
     base::CancelableTaskTracker* tracker) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "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 task runner for
   // the current message loop so that we can forward the call to the method
   // HistoryDBTask::DoneRunOnMainThread() in the correct thread.
-  thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTask,
-                            history_backend_, base::Passed(&task),
+  backend_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTask, history_backend_,
+                            base::Passed(&task),
                             base::ThreadTaskRunnerHandle::Get(), is_canceled));
   return task_id;
 }
 
 void HistoryService::FlushForTest(const base::Closure& flushed) {
-  thread_->task_runner()->PostTaskAndReply(
-      FROM_HERE, base::Bind(&base::DoNothing), flushed);
+  backend_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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(
       PRIORITY_NORMAL,
       base::Bind(&HistoryBackend::SetOnBackendDestroyTask, history_backend_,
                  base::ThreadTaskRunnerHandle::Get(), task));
 }
 
 void HistoryService::TopHosts(size_t num_hosts,
                               const TopHostsCallback& callback) const {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::TopHosts, history_backend_, num_hosts),
       callback);
 }
 
 void HistoryService::GetCountsAndLastVisitForOrigins(
     const std::set<GURL>& origins,
     const GetCountsAndLastVisitForOriginsCallback& callback) const {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetCountsAndLastVisitForOrigins,
                  history_backend_, origins),
       callback);
 }
 
 void HistoryService::HostRankIfAvailable(
     const GURL& url,
     const base::Callback<void(int)>& callback) const {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  PostTaskAndReplyWithResult(thread_->task_runner().get(), FROM_HERE,
-                             base::Bind(&HistoryBackend::HostRankIfAvailable,
-                                        history_backend_, url),
-                             callback);
+  PostTaskAndReplyWithResult(
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::HostRankIfAvailable, history_backend_, url),
+      callback);
 }
 
 void HistoryService::AddPage(const GURL& url,
                              Time time,
                              ContextID context_id,
                              int nav_entry_id,
                              const GURL& referrer,
                              const RedirectList& redirects,
                              ui::PageTransition transition,
                              VisitSource visit_source,
                              bool did_replace_entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
   AddPage(HistoryAddPageArgs(url, time, context_id, nav_entry_id, referrer,
                              redirects, transition, visit_source,
                              did_replace_entry, true));
 }
 
 void HistoryService::AddPage(const GURL& url,
                              base::Time time,
                              VisitSource visit_source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   AddPage(HistoryAddPageArgs(url, time, nullptr, 0, GURL(), RedirectList(),
                              ui::PAGE_TRANSITION_LINK, visit_source, false,
                              true));
 }
 
 void HistoryService::AddPage(const HistoryAddPageArgs& add_page_args) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Filter out unwanted URLs. We don't add auto-subframe URLs. They are a
   // large part of history (think iframes for ads) and we never display them in
   // history UI. We will still add manual subframes, which are ones the user
   // has clicked on to get.
   if (history_client_ && !history_client_->CanAddURL(add_page_args.url))
     return;
 
   // Inform VisitedDelegate of all links and redirects.
@@ skipping 10 matching lines @@
     }
   }
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPage, history_backend_,
                           add_page_args));
 }
 
 void HistoryService::AddPageNoVisitForBookmark(const GURL& url,
                                                const base::string16& title) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(url))
     return;
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPageNoVisitForBookmark,
                           history_backend_, url, title));
 }
 
 void HistoryService::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::SetPageTitle,
                                            history_backend_, url, title));
 }
 
 void HistoryService::UpdateWithPageEndTime(ContextID context_id,
                                            int nav_entry_id,
                                            const GURL& url,
                                            Time end_ts) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(
       PRIORITY_NORMAL,
       base::Bind(&HistoryBackend::UpdateWithPageEndTime, history_backend_,
                  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,
                                         VisitSource visit_source) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // Filter out unwanted URLs.
   if (history_client_ && !history_client_->CanAddURL(url))
     return;
 
   // Inform VisitDelegate of the URL.
   if (visit_delegate_)
     visit_delegate_->AddURL(url);
 
   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);
 
   URLRows rows;
   rows.push_back(row);
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPagesWithDetails,
                           history_backend_, rows, visit_source));
 }
 
 void HistoryService::AddPagesWithDetails(const URLRows& info,
                                          VisitSource visit_source) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Inform the VisitDelegate of the URLs
   if (!info.empty() && visit_delegate_) {
     std::vector<GURL> urls;
     urls.reserve(info.size());
     for (const auto& row : info)
       urls.push_back(row.url());
     visit_delegate_->AddURLs(urls);
   }
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPagesWithDetails,
                           history_backend_, 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) {
   TRACE_EVENT0("browser", "HistoryService::GetFavicons");
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "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_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFavicons, history_backend_,
-                 icon_urls, icon_types, desired_sizes, results),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetFavicons, history_backend_, 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) {
   TRACE_EVENT0("browser", "HistoryService::GetFaviconsForURL");
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "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_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFaviconsForURL, history_backend_,
-                 page_url, icon_types, desired_sizes, results),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetFaviconsForURL, history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_base::FaviconRawBitmapResult* result =
       new favicon_base::FaviconRawBitmapResult();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetLargestFaviconForURL,
-                 history_backend_, page_url, icon_types,
-                 minimum_size_in_pixels, result),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetLargestFaviconForURL, history_backend_,
+                 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) {
   TRACE_EVENT0("browser", "HistoryService::GetFaviconForID");
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "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_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFaviconForID, history_backend_,
-                 favicon_id, desired_size, results),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetFaviconForID, history_backend_, 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) {
   TRACE_EVENT0("browser", "HistoryService::UpdateFaviconMappingsAndFetch");
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "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_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
                  history_backend_, 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,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   TRACE_EVENT0("browser", "HistoryService::MergeFavicon");
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(page_url))
     return;
 
   ScheduleTask(
       PRIORITY_NORMAL,
       base::Bind(&HistoryBackend::MergeFavicon, history_backend_,
                  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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(page_url))
     return;
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::SetFavicons, history_backend_,
                           page_url, icon_type, icon_url, bitmaps));
 }
 
 void HistoryService::SetFaviconsOutOfDateForPage(const GURL& page_url) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::SetFaviconsOutOfDateForPage,
                           history_backend_, page_url));
 }
 
 void HistoryService::SetImportedFavicons(
     const favicon_base::FaviconUsageDataList& favicon_usage) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::SetImportedFavicons,
                           history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   QueryURLResult* query_url_result = new QueryURLResult();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryURL, history_backend_, url,
-                 want_visits, base::Unretained(query_url_result)),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::QueryURL, history_backend_, url, want_visits,
+                 base::Unretained(query_url_result)),
       base::Bind(&RunWithQueryURLResult, callback,
                  base::Owned(query_url_result)));
 }
 
 // Statistics ------------------------------------------------------------------
 
 base::CancelableTaskTracker::TaskId HistoryService::GetHistoryCount(
     const Time& begin_time,
     const Time& end_time,
     const GetHistoryCountCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return tracker->PostTaskAndReplyWithResult(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetHistoryCount,
-                 history_backend_,
-                 begin_time,
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetHistoryCount, history_backend_, begin_time,
                  end_time),
       callback);
 }
 
 // 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
-  PostTaskAndReplyWithResult(thread_->task_runner().get(), FROM_HERE,
+  PostTaskAndReplyWithResult(backend_task_runner_.get(), FROM_HERE,
                              base::Bind(&HistoryBackend::CreateDownload,
                                         history_backend_, create_info),
                              callback);
 }
 
 void HistoryService::GetNextDownloadId(const DownloadIdCallback& callback) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetNextDownloadId, history_backend_),
       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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<DownloadRow>* rows = new std::vector<DownloadRow>();
   std::unique_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_->task_runner()->PostTaskAndReply(
+  backend_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&HistoryBackend::QueryDownloads, history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::UpdateDownload,
                                            history_backend_, data));
 }
 
 void HistoryService::RemoveDownloads(const std::set<uint32_t>& ids) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::RemoveDownloads,
                                            history_backend_, ids));
 }
 
 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   QueryResults* query_results = new QueryResults();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryHistory, history_backend_,
-                 text_query, options, base::Unretained(query_results)),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::QueryHistory, history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryRedirectsFrom, history_backend_,
                  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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryRedirectsTo, history_backend_,
-                 to_url, base::Unretained(result)),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::QueryRedirectsTo, history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   VisibleVisitCountToHostResult* result = new VisibleVisitCountToHostResult();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetVisibleVisitCountToHost,
-                 history_backend_, url, base::Unretained(result)),
+      backend_task_runner_.get(), FROM_HERE,
+      base::Bind(&HistoryBackend::GetVisibleVisitCountToHost, history_backend_,
+                 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   MostVisitedURLList* result = new MostVisitedURLList();
   return tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_task_runner_.get(), FROM_HERE,
       base::Bind(&HistoryBackend::QueryMostVisitedURLs, history_backend_,
                  result_count, days_back, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 void HistoryService::Cleanup() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!thread_) {
+  if (!backend_task_runner_) {
     // We've already cleaned up.
     return;
   }
 
   NotifyHistoryServiceBeingDeleted();
 
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Inform the HistoryClient that we are shuting down.
   if (history_client_)
@@ skipping 24 matching lines @@
     //
     // TODO(ajwong): Cleanup HistoryBackend lifetime issues.
     //     See http://crbug.com/99767.
     history_backend_->AddRef();
     base::Closure closing_task =
         base::Bind(&HistoryBackend::Closing, history_backend_);
     ScheduleTask(PRIORITY_NORMAL, closing_task);
     closing_task.Reset();
     HistoryBackend* raw_ptr = history_backend_.get();
     history_backend_ = nullptr;
-    thread_->task_runner()->ReleaseSoon(FROM_HERE, raw_ptr);
+    backend_task_runner_->ReleaseSoon(FROM_HERE, raw_ptr);
   }
 
-  // Delete the thread, which joins with the background thread. We defensively
-  // nullptr the pointer before deleting it in case somebody tries to use it
-  // during shutdown, but this shouldn't happen.
-  base::Thread* thread = thread_;
-  thread_ = nullptr;
-  delete thread;
+  // Clear |backend_task_runner_| to make sure it's not used after Cleanup().
+  backend_task_runner_ = nullptr;

[gab, 2016/11/08 19:15:43]

To mimic identical shutdown behavior here while in redirection mode:

Post a WaitableEvent::Signal() task to |backend_task_runner_| and synchronously
block on it here? With a TODO to consider removing it in a follow-up (i.e. so
that changing the shutdown order isn't convoluted with this change and can be
reasoned about on its own).

+
+  // Join the background thread, if any.
+  thread_.reset();
 }
 
 bool HistoryService::Init(
     bool no_db,
     const HistoryDatabaseParams& history_database_params) {
   TRACE_EVENT0("browser,startup", "HistoryService::Init")
   SCOPED_UMA_HISTOGRAM_TIMER("History.HistoryServiceInitTime");
-  DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!backend_task_runner_);
 
-  base::Thread::Options options;
-  options.timer_slack = base::TIMER_SLACK_MAXIMUM;
-  if (!thread_->StartWithOptions(options)) {
-    Cleanup();
-    return false;
+  if (thread_) {
+    base::Thread::Options options;
+    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+    if (!thread_->StartWithOptions(options)) {
+      Cleanup();
+      return false;
+    }
+    backend_task_runner_ = thread_->task_runner();
+  } else {
+    backend_task_runner_ = base::CreateSequencedTaskRunnerWithTraits(
+        base::TaskTraits()
+            .WithPriority(base::TaskPriority::USER_BLOCKING)
+            .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN)
+            .WithFileIO());
   }
 
   // Create the history backend.
   scoped_refptr<HistoryBackend> backend(new HistoryBackend(
       new BackendDelegate(weak_ptr_factory_.GetWeakPtr(),
                           base::ThreadTaskRunnerHandle::Get()),
       history_client_ ? history_client_->CreateBackendClient() : nullptr,
-      thread_->task_runner()));
+      backend_task_runner_));
   history_backend_.swap(backend);
 
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::Init, history_backend_,
                           no_db, history_database_params));
 
   if (visit_delegate_ && !visit_delegate_->Init(this))
     return false;
 
   if (history_client_)
     history_client_->OnHistoryServiceCreated(this);
 
   return true;
 }
 
 void HistoryService::ScheduleAutocomplete(
     const base::Callback<void(HistoryBackend*, URLDatabase*)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI, base::Bind(&HistoryBackend::ScheduleAutocomplete,
                                        history_backend_, callback));
 }
 
 void HistoryService::ScheduleTask(SchedulePriority priority,
                                   const base::Closure& task) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  CHECK(thread_);
-  CHECK(thread_->message_loop());
+  CHECK(backend_task_runner_);
   // TODO(brettw): Do prioritization.
-  thread_->task_runner()->PostTask(FROM_HERE, task);
+  backend_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 45 matching lines @@
 }
 
 void HistoryService::NotifyProfileError(sql::InitStatus init_status,
                                         const std::string& diagnostics) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_)
     history_client_->NotifyProfileError(init_status, diagnostics);
 }
 
 void HistoryService::DeleteURL(const GURL& url) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete notifications.
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURL,
                                            history_backend_, url));
 }
 
 void HistoryService::DeleteURLsForTest(const std::vector<GURL>& urls) {
-  DCHECK(thread_) << "History service being called after cleanup";
+  DCHECK(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete
   // notifications.
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURLs,
                                            history_backend_, 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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_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(backend_task_runner_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   tracker->PostTaskAndReply(
-      thread_->task_runner().get(), FROM_HERE,
+      backend_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 37 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   for (HistoryServiceObserver& observer : observers_)
     observer.OnURLsModified(this, changed_urls);
 }
 
 void HistoryService::NotifyURLsDeleted(bool all_history,
                                        bool expired,
                                        const URLRows& deleted_rows,
                                        const std::set<GURL>& favicon_urls) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!thread_)
+  if (!backend_task_runner_)
     return;
 
   // Inform the VisitDelegate of the deleted URLs. We will inform the delegate
   // of added URLs as soon as we get the add notification (we don't have to wait
   // for the backend, which allows us to be faster to update the state).
   //
   // For deleted URLs, we don't typically know what will be deleted since
   // delete notifications are by time. We would also like to be more
   // respectful of privacy and never tell the user something is gone when it
   // isn't. Therefore, we update the delete URLs after the fact.
@@ skipping 50 matching lines @@
   return favicon_changed_callback_list_.Add(callback);
 }
 
 void HistoryService::NotifyFaviconsChanged(const std::set<GURL>& page_urls,
                                            const GURL& icon_url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_changed_callback_list_.Notify(page_urls, icon_url);
 }
 
 }  // namespace history