Document that HistoryBackend is sequence-affine, not thread-affine.

components/history/core/browser/history_backend.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.
 
 #include "components/history/core/browser/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 199 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : delegate_(delegate),
       scheduled_kill_db_(false),
       expirer_(this, backend_client.get(), task_runner),
       recent_redirects_(kMaxRedirectCount),
       segment_queried_(false),
       backend_client_(std::move(backend_client)),
       task_runner_(task_runner) {}
 
 HistoryBackend::~HistoryBackend() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!scheduled_commit_) << "Deleting without cleanup";
   queued_history_db_tasks_.clear();
 
   // Release stashed embedder object before cleaning up the databases.
   supports_user_data_helper_.reset();
 
   // First close the databases before optionally running the "destroy" task.
   CloseAllDatabases();
 
   if (!backend_destroy_task_.is_null()) {
     // Notify an interested party (typically a unit test) that we're done.
     DCHECK(backend_destroy_task_runner_);
     backend_destroy_task_runner_->PostTask(FROM_HERE, backend_destroy_task_);
   }
 
 #if defined(OS_ANDROID)
   if (backend_client_ && !history_dir_.empty())
     backend_client_->OnHistoryBackendDestroyed(this, history_dir_);
 #endif
 }
 
 void HistoryBackend::Init(
     bool force_fail,
     const HistoryDatabaseParams& history_database_params) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // HistoryBackend is created on the UI thread by HistoryService, then the
   // HistoryBackend::Init() method is called on the DB thread. Create the
   // base::SupportsUserData on the DB thread since it is not thread-safe.
   supports_user_data_helper_.reset(new HistoryBackendHelper);
 
   if (!force_fail)
     InitImpl(history_database_params);
   delegate_->DBLoaded();
   typed_url_syncable_service_.reset(new TypedUrlSyncableService(this));
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&HistoryBackend::OnMemoryPressure, base::Unretained(this))));
 }
 
 void HistoryBackend::SetOnBackendDestroyTask(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const base::Closure& task) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!backend_destroy_task_.is_null())
     DLOG(WARNING) << "Setting more than one destroy task, overriding";
   backend_destroy_task_runner_ = std::move(task_runner);
   backend_destroy_task_ = task;
 }
 
 void HistoryBackend::Closing() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Any scheduled commit will have a reference to us, we must make it
   // release that reference before we can be destroyed.
   CancelScheduledCommit();
 
   // Release our reference to the delegate, this reference will be keeping the
   // history service alive.
   delegate_.reset();
 }
 
 #if defined(OS_IOS)
 void HistoryBackend::PersistState() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   Commit();
 }
 #endif
 
 void HistoryBackend::ClearCachedDataForContextID(ContextID context_id) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   tracker_.ClearCachedDataForContextID(context_id);
 }
 
 base::FilePath HistoryBackend::GetFaviconsFileName() const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return history_dir_.Append(kFaviconsFilename);
 }
 
 SegmentID HistoryBackend::GetLastSegmentID(VisitID from_visit) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Set is used to detect referrer loops.  Should not happen, but can
   // if the database is corrupt.
   std::set<VisitID> visit_set;
   VisitID visit_id = from_visit;
   while (visit_id) {
     VisitRow row;
     if (!db_->GetRowForVisit(visit_id, &row))
       return 0;
     if (row.segment_id)
       return row.segment_id;  // Found a visit in this change with a segment.
 
     // Check the referrer of this visit, if any.
     visit_id = row.referring_visit;
 
     if (visit_set.find(visit_id) != visit_set.end()) {
       NOTREACHED() << "Loop in referer chain, giving up";
       break;
     }
     visit_set.insert(visit_id);
   }
   return 0;
 }
 
 SegmentID HistoryBackend::UpdateSegments(const GURL& url,
                                          VisitID from_visit,
                                          VisitID visit_id,
                                          ui::PageTransition transition_type,
                                          const Time ts) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return 0;
 
   // We only consider main frames.
   if (!ui::PageTransitionIsMainFrame(transition_type))
     return 0;
 
   SegmentID segment_id = 0;
 
   // Are we at the beginning of a new segment?
@@ skipping 54 matching lines @@
     NOTREACHED();
     return 0;
   }
   return segment_id;
 }
 
 void HistoryBackend::UpdateWithPageEndTime(ContextID context_id,
                                            int nav_entry_id,
                                            const GURL& url,
                                            Time end_ts) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Will be filled with the URL ID and the visit ID of the last addition.
   VisitID visit_id = tracker_.GetLastVisit(context_id, nav_entry_id, url);
   UpdateVisitDuration(visit_id, end_ts);
 }
 
 void HistoryBackend::UpdateVisitDuration(VisitID visit_id, const Time end_ts) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   // Get the starting visit_time for visit_id.
   VisitRow visit_row;
   if (db_->GetRowForVisit(visit_id, &visit_row)) {
     // We should never have a negative duration time even when time is skewed.
     visit_row.visit_duration = end_ts > visit_row.visit_time
                                    ? end_ts - visit_row.visit_time
                                    : TimeDelta::FromMicroseconds(0);
     db_->UpdateVisitRow(visit_row);
   }
 }
 
 TopHostsList HistoryBackend::TopHosts(size_t num_hosts) const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return TopHostsList();
 
   auto top_hosts = db_->TopHosts(num_hosts);
 
   host_ranks_.clear();
   int i = 0;
   for (const auto& host_count : top_hosts)
     host_ranks_[host_count.first] = i++;
   return top_hosts;
 }
 
 OriginCountAndLastVisitMap HistoryBackend::GetCountsAndLastVisitForOrigins(
     const std::set<GURL>& origins) const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return OriginCountAndLastVisitMap();
 
   URLDatabase::URLEnumerator it;
   if (!db_->InitURLEnumeratorForEverything(&it))
     return OriginCountAndLastVisitMap();
 
   OriginCountAndLastVisitMap origin_count_map;
   for (const GURL& origin : origins)
     origin_count_map[origin] = std::make_pair(0, base::Time());
 
   URLRow row;
   while (it.GetNextURL(&row)) {
     GURL origin = row.url().GetOrigin();
     auto iter = origin_count_map.find(origin);
     if (iter != origin_count_map.end()) {
       std::pair<int, base::Time>& value = iter->second;
       ++(value.first);
       if (value.second.is_null() || value.second < row.last_visit())
         value.second = row.last_visit();
     }
   }
 
   return origin_count_map;
 }
 
 int HistoryBackend::HostRankIfAvailable(const GURL& url) const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   auto it = host_ranks_.find(HostForTopHosts(url));
   return it != host_ranks_.end() ? it->second : kMaxTopHosts;
 }
 
 void HistoryBackend::AddPage(const HistoryAddPageArgs& request) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   // Will be filled with the URL ID and the visit ID of the last addition.
   std::pair<URLID, VisitID> last_ids(
       0, tracker_.GetLastVisit(request.context_id, request.nav_entry_id,
                                request.referrer));
 
   VisitID from_visit_id = last_ids.second;
 
@@ skipping 152 matching lines @@
       !is_keyword_generated) {
     tracker_.AddVisit(request.context_id, request.nav_entry_id, request.url,
                       last_ids.second);
   }
 
   ScheduleCommit();
 }
 
 void HistoryBackend::InitImpl(
     const HistoryDatabaseParams& history_database_params) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   DCHECK(!db_) << "Initializing HistoryBackend twice";
   // In the rare case where the db fails to initialize a dialog may get shown
   // the blocks the caller, yet allows other messages through. For this reason
   // we only set db_ to the created database if creation is successful. That
   // way other methods won't do anything as db_ is still null.
 
   TimeTicks beginning_time = TimeTicks::Now();
 
   // Compute the file names.
   history_dir_ = history_database_params.history_dir;
@@ skipping 90 matching lines @@
     backend_client_->OnHistoryBackendInitialized(
         this, db_.get(), thumbnail_db_.get(), history_dir_);
   }
 #endif
 
   LOCAL_HISTOGRAM_TIMES("History.InitTime", TimeTicks::Now() - beginning_time);
 }
 
 void HistoryBackend::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   bool trim_aggressively =
       memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
   if (db_)
     db_->TrimMemory(trim_aggressively);
   if (thumbnail_db_)
     thumbnail_db_->TrimMemory(trim_aggressively);
 }
 
 void HistoryBackend::CloseAllDatabases() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_) {
     // Commit the long-running transaction.
     db_->CommitTransaction();
     db_.reset();
     // Forget the first recorded time since the database is closed.
     first_recorded_time_ = base::Time();
   }
   if (thumbnail_db_) {
     thumbnail_db_->CommitTransaction();
     thumbnail_db_.reset();
   }
 }
 
 void HistoryBackend::RecordTopHostsMetrics(const GURL& url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Convert index from 0-based to 1-based.
   UMA_HISTOGRAM_ENUMERATION("History.TopHostsVisitsByRank",
                             HostRankIfAvailable(url) + 1, kMaxTopHosts + 2);
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
     VisitID referring_visit,
     ui::PageTransition transition,
     VisitSource visit_source) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Top-level frame navigations are visible, everything else is hidden
   bool new_hidden = !ui::PageTransitionIsMainFrame(transition);
 
   // NOTE: This code must stay in sync with
   // ExpireHistoryBackend::ExpireURLsForVisits().
   int typed_increment = 0;
   if (ui::PageTransitionIsNewNavigation(transition) &&
       ((ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_TYPED) &&
         !ui::PageTransitionIsRedirect(transition)) ||
        ui::PageTransitionCoreTypeIs(transition,
@@ skipping 54 matching lines @@
   } else {
     DVLOG(0) << "Failed to build visit insert statement:  "
              << "url_id = " << url_id;
   }
 
   return std::make_pair(url_id, visit_id);
 }
 
 void HistoryBackend::AddPagesWithDetails(const URLRows& urls,
                                          VisitSource visit_source) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   URLRows changed_urls;
   for (URLRows::const_iterator i = urls.begin(); i != urls.end(); ++i) {
     DCHECK(!i->last_visit().is_null());
 
     // As of M37, we no longer maintain an archived database, ignore old visits.
     if (IsExpiredVisitTime(i->last_visit()))
       continue;
@@ skipping 34 matching lines @@
   // Broadcast a notification for typed URLs that have been modified. This
   // will be picked up by the in-memory URL database on the main thread.
   //
   // TODO(brettw) bug 1140015: Add an "add page" notification so the history
   // views can keep in sync.
   NotifyURLsModified(changed_urls);
   ScheduleCommit();
 }
 
 bool HistoryBackend::IsExpiredVisitTime(const base::Time& time) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return time < expirer_.GetCurrentExpirationTime();
 }
 
 void HistoryBackend::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   // Search for recent redirects which should get the same title. We make a
   // dummy list containing the exact URL visited if there are no redirects so
   // the processing below can be the same.
   RedirectList dummy_list;
   RedirectList* redirects;
   RedirectCache::iterator iter = recent_redirects_.Get(url);
   if (iter != recent_redirects_.end()) {
@@ skipping 23 matching lines @@
   // Broadcast notifications for any URLs that have changed. This will
   // update the in-memory database and the InMemoryURLIndex.
   if (!changed_urls.empty()) {
     NotifyURLsModified(changed_urls);
     ScheduleCommit();
   }
 }
 
 void HistoryBackend::AddPageNoVisitForBookmark(const GURL& url,
                                                const base::string16& title) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   URLRow url_info(url);
   URLID url_id = db_->GetRowForURL(url, &url_info);
   if (url_id) {
     // URL is already known, nothing to do.
     return;
   }
 
   if (!title.empty()) {
     url_info.set_title(title);
   } else {
     url_info.set_title(base::UTF8ToUTF16(url.spec()));
   }
 
   url_info.set_last_visit(Time::Now());
   // Mark the page hidden. If the user types it in, it'll unhide.
   url_info.set_hidden(true);
 
   db_->AddURL(url_info);
 }
 
 bool HistoryBackend::GetAllTypedURLs(URLRows* urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_)
     return db_->GetAllTypedUrls(urls);
   return false;
 }
 
 bool HistoryBackend::GetVisitsForURL(URLID id, VisitVector* visits) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_)
     return db_->GetVisitsForURL(id, visits);
   return false;
 }
 
 bool HistoryBackend::GetMostRecentVisitsForURL(URLID id,
                                                int max_visits,
                                                VisitVector* visits) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_)
     return db_->GetMostRecentVisitsForURL(id, max_visits, visits);
   return false;
 }
 
 size_t HistoryBackend::UpdateURLs(const URLRows& urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return 0;
 
   URLRows changed_urls;
   for (URLRows::const_iterator it = urls.begin(); it != urls.end(); ++it) {
     DCHECK(it->id());
     if (db_->UpdateURLRow(it->id(), *it))
       changed_urls.push_back(*it);
   }
 
   // Broadcast notifications for any URLs that have actually been changed. This
   // will update the in-memory database and the InMemoryURLIndex.
   size_t num_updated_records = changed_urls.size();
   if (num_updated_records) {
     NotifyURLsModified(changed_urls);
     ScheduleCommit();
   }
   return num_updated_records;
 }
 
 bool HistoryBackend::AddVisits(const GURL& url,
                                const std::vector<VisitInfo>& visits,
                                VisitSource visit_source) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_) {
     for (std::vector<VisitInfo>::const_iterator visit = visits.begin();
          visit != visits.end(); ++visit) {
       if (!AddPageVisit(url, visit->first, 0, visit->second, visit_source)
                .first) {
         return false;
       }
     }
     ScheduleCommit();
     return true;
   }
   return false;
 }
 
 bool HistoryBackend::RemoveVisits(const VisitVector& visits) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return false;
 
   expirer_.ExpireVisits(visits);
   ScheduleCommit();
   return true;
 }
 
 bool HistoryBackend::GetVisitsSource(const VisitVector& visits,
                                      VisitSourceMap* sources) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return false;
 
   db_->GetVisitsSource(visits, sources);
   return true;
 }
 
 bool HistoryBackend::GetURL(const GURL& url, URLRow* url_row) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_)
     return db_->GetRowForURL(url, url_row) != 0;
   return false;
 }
 
 void HistoryBackend::QueryURL(const GURL& url,
                               bool want_visits,
                               QueryURLResult* result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(result);
   result->success = db_ && db_->GetRowForURL(url, &result->row);
   // Optionally query the visits.
   if (result->success && want_visits)
     db_->GetVisitsForURL(result->row.id(), &result->visits);
 }
 
 TypedUrlSyncableService* HistoryBackend::GetTypedUrlSyncableService() const {
   return typed_url_syncable_service_.get();
 }
 
 // Statistics ------------------------------------------------------------------
 
 HistoryCountResult HistoryBackend::GetHistoryCount(const Time& begin_time,
                                                    const Time& end_time) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   HistoryCountResult result;
   result.count = 0;
   result.success =
       db_ && db_->GetHistoryCount(begin_time, end_time, &result.count);
   return result;
 }
 
 // Keyword visits --------------------------------------------------------------
 
 void HistoryBackend::SetKeywordSearchTermsForURL(const GURL& url,
                                                  KeywordID keyword_id,
                                                  const base::string16& term) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   // Get the ID for this URL.
   URLRow row;
   if (!db_->GetRowForURL(url, &row)) {
     // There is a small possibility the url was deleted before the keyword
     // was added. Ignore the request.
     return;
   }
 
   db_->SetKeywordSearchTermsForURL(row.id(), keyword_id, term);
 
   if (delegate_)
     delegate_->NotifyKeywordSearchTermUpdated(row, keyword_id, term);
 
   ScheduleCommit();
 }
 
 void HistoryBackend::DeleteAllSearchTermsForKeyword(KeywordID keyword_id) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   db_->DeleteAllSearchTermsForKeyword(keyword_id);
   ScheduleCommit();
 }
 
 void HistoryBackend::DeleteKeywordSearchTermForURL(const GURL& url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   URLID url_id = db_->GetRowForURL(url, nullptr);
   if (!url_id)
     return;
   db_->DeleteKeywordSearchTermForURL(url_id);
 
   if (delegate_)
     delegate_->NotifyKeywordSearchTermDeleted(url_id);
 
   ScheduleCommit();
 }
 
 void HistoryBackend::DeleteMatchingURLsForKeyword(KeywordID keyword_id,
                                                   const base::string16& term) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   std::vector<KeywordSearchTermRow> rows;
   if (db_->GetKeywordSearchTermRows(term, &rows)) {
     std::vector<GURL> items_to_delete;
     URLRow row;
     for (std::vector<KeywordSearchTermRow>::iterator it = rows.begin();
          it != rows.end(); ++it) {
       if ((it->keyword_id == keyword_id) && db_->GetURLRow(it->url_id, &row))
         items_to_delete.push_back(row.url());
     }
     DeleteURLs(items_to_delete);
   }
 }
 
 // Observers -------------------------------------------------------------------
 
 void HistoryBackend::AddObserver(HistoryBackendObserver* observer) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   observers_.AddObserver(observer);
 }
 
 void HistoryBackend::RemoveObserver(HistoryBackendObserver* observer) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   observers_.RemoveObserver(observer);
 }
 
 // Downloads -------------------------------------------------------------------
 
 uint32_t HistoryBackend::GetNextDownloadId() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return db_ ? db_->GetNextDownloadId() : kInvalidDownloadId;
 }
 
 // Get all the download entries from the database.
 void HistoryBackend::QueryDownloads(std::vector<DownloadRow>* rows) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_)
     db_->QueryDownloads(rows);
 }
 
 // Update a particular download entry.
 void HistoryBackend::UpdateDownload(
     const DownloadRow& data,
     bool should_commit_immediately) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
   db_->UpdateDownload(data);
   if (should_commit_immediately)
     Commit();
   else
     ScheduleCommit();
 }
 
 bool HistoryBackend::CreateDownload(const DownloadRow& history_info) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return false;
   bool success = db_->CreateDownload(history_info);
 #if defined(OS_ANDROID)
   // On android, browser process can get easily killed. Download will no longer
   // be able to resume and the temporary file will linger forever if the
   // download is not committed before that. Do the commit right away to avoid
   // uncommitted download entry if browser is killed.
   Commit();
 #else
   ScheduleCommit();
 #endif
   return success;
 }
 
 void HistoryBackend::RemoveDownloads(const std::set<uint32_t>& ids) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
   size_t downloads_count_before = db_->CountDownloads();
   base::TimeTicks started_removing = base::TimeTicks::Now();
   // HistoryBackend uses a long-running Transaction that is committed
   // periodically, so this loop doesn't actually hit the disk too hard.
   for (std::set<uint32_t>::const_iterator it = ids.begin(); it != ids.end();
        ++it) {
     db_->RemoveDownload(*it);
   }
@@ skipping 12 matching lines @@
   if (num_downloads_deleted > 0) {
     UMA_HISTOGRAM_TIMES("Download.DatabaseRemoveDownloadsTimePerRecord",
                         (1000 * micros) / num_downloads_deleted);
   }
   DCHECK_GE(ids.size(), num_downloads_deleted);
 }
 
 void HistoryBackend::QueryHistory(const base::string16& text_query,
                                   const QueryOptions& options,
                                   QueryResults* query_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   DCHECK(query_results);
   base::TimeTicks beginning_time = base::TimeTicks::Now();
   if (db_) {
     if (text_query.empty()) {
       // Basic history query for the main database.
       QueryHistoryBasic(options, query_results);
     } else {
       // Text history query.
       QueryHistoryText(text_query, options, query_results);
     }
   }
   UMA_HISTOGRAM_TIMES("History.QueryHistory",
                       TimeTicks::Now() - beginning_time);
 }
 
 // Basic time-based querying of history.
 void HistoryBackend::QueryHistoryBasic(const QueryOptions& options,
                                        QueryResults* result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // First get all visits.
   VisitVector visits;
   bool has_more_results = db_->GetVisibleVisitsInRange(options, &visits);
   DCHECK_LE(static_cast<int>(visits.size()), options.EffectiveMaxCount());
 
   // Now add them and the URL rows to the results.
   URLResult url_result;
   for (size_t i = 0; i < visits.size(); i++) {
     const VisitRow visit = visits[i];
 
@@ skipping 22 matching lines @@
   }
 
   if (!has_more_results && options.begin_time <= first_recorded_time_)
     result->set_reached_beginning(true);
 }
 
 // Text-based querying of history.
 void HistoryBackend::QueryHistoryText(const base::string16& text_query,
                                       const QueryOptions& options,
                                       QueryResults* result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   URLRows text_matches;
   db_->GetTextMatchesWithAlgorithm(text_query, options.matching_algorithm,
                                    &text_matches);
 
   std::vector<URLResult> matching_visits;
   VisitVector visits;  // Declare outside loop to prevent re-construction.
   for (size_t i = 0; i < text_matches.size(); i++) {
     const URLRow& text_match = text_matches[i];
     // Get all visits for given URL match.
     db_->GetVisibleVisitsForURL(text_match.id(), options, &visits);
@@ skipping 15 matching lines @@
     result->AppendURLBySwapping(&(*it));
   }
 
   if (matching_visits.size() == result->size() &&
       options.begin_time <= first_recorded_time_)
     result->set_reached_beginning(true);
 }
 
 void HistoryBackend::QueryRedirectsFrom(const GURL& from_url,
                                         RedirectList* redirects) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   redirects->clear();
   if (!db_)
     return;
 
   URLID from_url_id = db_->GetRowForURL(from_url, nullptr);
   VisitID cur_visit = db_->GetMostRecentVisitForURL(from_url_id, nullptr);
   if (!cur_visit)
     return;  // No visits for URL.
 
   GetRedirectsFromSpecificVisit(cur_visit, redirects);
 }
 
 void HistoryBackend::QueryRedirectsTo(const GURL& to_url,
                                       RedirectList* redirects) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   redirects->clear();
   if (!db_)
     return;
 
   URLID to_url_id = db_->GetRowForURL(to_url, nullptr);
   VisitID cur_visit = db_->GetMostRecentVisitForURL(to_url_id, nullptr);
   if (!cur_visit)
     return;  // No visits for URL.
 
   GetRedirectsToSpecificVisit(cur_visit, redirects);
 }
 
 void HistoryBackend::GetVisibleVisitCountToHost(
     const GURL& url,
     VisibleVisitCountToHostResult* result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   result->count = 0;
   result->success = db_ &&
                     db_->GetVisibleVisitCountToHost(url, &result->count,
                                                     &result->first_visit);
 }
 
 void HistoryBackend::QueryMostVisitedURLs(int result_count,
                                           int days_back,
                                           MostVisitedURLList* result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   auto url_filter = backend_client_
                         ? base::Bind(&HistoryBackendClient::IsWebSafe,
                                      base::Unretained(backend_client_.get()))
                         : base::Callback<bool(const GURL&)>();
   std::vector<std::unique_ptr<PageUsageData>> data = db_->QuerySegmentUsage(
       base::Time::Now() - base::TimeDelta::FromDays(days_back), result_count,
       url_filter);
 
   for (const std::unique_ptr<PageUsageData>& current_data : data) {
     RedirectList redirects;
     QueryRedirectsFrom(current_data->GetURL(), &redirects);
     MostVisitedURL url = MakeMostVisitedURL(*current_data, redirects);
     result->push_back(url);
   }
 }
 
 void HistoryBackend::GetRedirectsFromSpecificVisit(VisitID cur_visit,
                                                    RedirectList* redirects) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Follow any redirects from the given visit and add them to the list.
   // It *should* be impossible to get a circular chain here, but we check
   // just in case to avoid infinite loops.
   GURL cur_url;
   std::set<VisitID> visit_set;
   visit_set.insert(cur_visit);
   while (db_->GetRedirectFromVisit(cur_visit, &cur_visit, &cur_url)) {
     if (visit_set.find(cur_visit) != visit_set.end()) {
       NOTREACHED() << "Loop in visit chain, giving up";
       return;
     }
     visit_set.insert(cur_visit);
     redirects->push_back(cur_url);
   }
 }
 
 void HistoryBackend::GetRedirectsToSpecificVisit(VisitID cur_visit,
                                                  RedirectList* redirects) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Follow redirects going to cur_visit. These are added to |redirects| in
   // the order they are found. If a redirect chain looks like A -> B -> C and
   // |cur_visit| = C, redirects will be {B, A} in that order.
   if (!db_)
     return;
 
   GURL cur_url;
   std::set<VisitID> visit_set;
   visit_set.insert(cur_visit);
   while (db_->GetRedirectToVisit(cur_visit, &cur_visit, &cur_url)) {
     if (visit_set.find(cur_visit) != visit_set.end()) {
       NOTREACHED() << "Loop in visit chain, giving up";
       return;
     }
     visit_set.insert(cur_visit);
     redirects->push_back(cur_url);
   }
 }
 
 void HistoryBackend::ScheduleAutocomplete(
     const base::Callback<void(HistoryBackend*, URLDatabase*)>& callback) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   callback.Run(this, db_.get());
 }
 
 void HistoryBackend::DeleteFTSIndexDatabases() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Find files on disk matching the text databases file pattern so we can
   // quickly test for and delete them.
   base::FilePath::StringType filepattern = FILE_PATH_LITERAL("History Index *");
   base::FileEnumerator enumerator(history_dir_, false,
                                   base::FileEnumerator::FILES, filepattern);
   int num_databases_deleted = 0;
   base::FilePath current_file;
   while (!(current_file = enumerator.Next()).empty()) {
     if (sql::Connection::Delete(current_file))
       num_databases_deleted++;
   }
   UMA_HISTOGRAM_COUNTS("History.DeleteFTSIndexDatabases",
                        num_databases_deleted);
 }
 
 void HistoryBackend::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   UpdateFaviconMappingsAndFetchImpl(nullptr, icon_urls, icon_types,
                                     desired_sizes, bitmap_results);
 }
 
 void HistoryBackend::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     favicon_base::FaviconRawBitmapResult* favicon_bitmap_result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(favicon_bitmap_result);
 
   if (!db_ || !thumbnail_db_)
     return;
 
   TimeTicks beginning_time = TimeTicks::Now();
 
   std::vector<IconMapping> icon_mappings;
   if (!thumbnail_db_->GetIconMappingsForPageURL(page_url, &icon_mappings) ||
       icon_mappings.empty())
@@ skipping 76 matching lines @@
   LOCAL_HISTOGRAM_TIMES("History.GetLargestFaviconForURL",
                         TimeTicks::Now() - beginning_time);
 }
 
 void HistoryBackend::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   TRACE_EVENT0("browser", "HistoryBackend::GetFaviconsForURL");
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(bitmap_results);
   GetFaviconsFromDB(page_url, icon_types, desired_sizes, bitmap_results);
 
   if (desired_sizes.size() == 1)
     bitmap_results->assign(1, favicon_base::ResizeFaviconBitmapResult(
                                   *bitmap_results, desired_sizes[0]));
 }
 
 void HistoryBackend::GetFaviconForID(
     favicon_base::FaviconID favicon_id,
     int desired_size,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   TRACE_EVENT0("browser", "HistoryBackend::GetFaviconForID");
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   std::vector<favicon_base::FaviconID> favicon_ids;
   favicon_ids.push_back(favicon_id);
   std::vector<int> desired_sizes;
   desired_sizes.push_back(desired_size);
 
   // Get results from DB.
   GetFaviconBitmapResultsForBestMatch(favicon_ids, desired_sizes,
                                       bitmap_results);
 
   bitmap_results->assign(1, favicon_base::ResizeFaviconBitmapResult(
                                 *bitmap_results, desired_size));
 }
 
 void HistoryBackend::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   UpdateFaviconMappingsAndFetchImpl(&page_url, icon_urls, icon_types,
                                     desired_sizes, bitmap_results);
 }
 
 void HistoryBackend::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) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!thumbnail_db_ || !db_)
     return;
 
   favicon_base::FaviconID favicon_id =
       thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
   bool favicon_created = false;
   if (!favicon_id) {
     // There is no favicon at |icon_url|, create it.
     favicon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
@@ skipping 136 matching lines @@
     SendFaviconChangedNotificationForIconURL(icon_url);
   }
 
   ScheduleCommit();
 }
 
 void HistoryBackend::SetFavicons(const GURL& page_url,
                                  favicon_base::IconType icon_type,
                                  const GURL& icon_url,
                                  const std::vector<SkBitmap>& bitmaps) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!thumbnail_db_ || !db_)
     return;
 
   DCHECK_GE(kMaxFaviconBitmapsPerIconURL, bitmaps.size());
 
   favicon_base::FaviconID icon_id =
       thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
   bool favicon_created = false;
   if (!icon_id) {
@@ skipping 15 matching lines @@
   if (favicon_data_modified && !favicon_created) {
     // If there was a favicon at |icon_url| prior to SetFavicons() being called,
     // there may be page URLs which also use the favicon at |icon_url|. Notify
     // the UI that the favicon has changed for |icon_url|.
     SendFaviconChangedNotificationForIconURL(icon_url);
   }
   ScheduleCommit();
 }
 
 void HistoryBackend::SetFaviconsOutOfDateForPage(const GURL& page_url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   std::vector<IconMapping> icon_mappings;
 
   if (!thumbnail_db_ ||
       !thumbnail_db_->GetIconMappingsForPageURL(page_url, &icon_mappings))
     return;
 
   for (std::vector<IconMapping>::iterator m = icon_mappings.begin();
        m != icon_mappings.end(); ++m) {
     thumbnail_db_->SetFaviconOutOfDate(m->icon_id);
   }
   ScheduleCommit();
 }
 
 void HistoryBackend::SetImportedFavicons(
     const favicon_base::FaviconUsageDataList& favicon_usage) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_ || !thumbnail_db_)
     return;
 
   Time now = Time::Now();
 
   // Track all URLs that had their favicons set or updated.
   std::set<GURL> favicons_changed;
 
   for (size_t i = 0; i < favicon_usage.size(); i++) {
     favicon_base::FaviconID favicon_id =
@@ skipping 45 matching lines @@
     NotifyFaviconsChanged(favicons_changed, GURL());
   }
 }
 
 void HistoryBackend::UpdateFaviconMappingsAndFetchImpl(
     const GURL* page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // If |page_url| is specified, |icon_types| must be either a single icon
   // type or icon types which are equivalent.
   DCHECK(!page_url || icon_types == favicon_base::FAVICON ||
          icon_types == favicon_base::TOUCH_ICON ||
          icon_types == favicon_base::TOUCH_PRECOMPOSED_ICON ||
          icon_types ==
              (favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON));
   bitmap_results->clear();
 
   if (!thumbnail_db_) {
@@ skipping 34 matching lines @@
       ScheduleCommit();
     }
   }
 
   GetFaviconBitmapResultsForBestMatch(favicon_ids, desired_sizes,
                                       bitmap_results);
 }
 
 bool HistoryBackend::SetFaviconBitmaps(favicon_base::FaviconID icon_id,
                                        const std::vector<SkBitmap>& bitmaps) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
   thumbnail_db_->GetFaviconBitmapIDSizes(icon_id, &bitmap_id_sizes);
 
   typedef std::pair<scoped_refptr<base::RefCountedBytes>, gfx::Size>
       PNGEncodedBitmap;
   std::vector<PNGEncodedBitmap> to_add;
   for (size_t i = 0; i < bitmaps.size(); ++i) {
     scoped_refptr<base::RefCountedBytes> bitmap_data(new base::RefCountedBytes);
     if (!gfx::PNGCodec::EncodeBGRASkBitmap(bitmaps[i], false,
                                            &bitmap_data->data())) {
@@ skipping 39 matching lines @@
                                     to_add[i].second);
 
     favicon_bitmaps_changed = true;
   }
   return favicon_bitmaps_changed;
 }
 
 bool HistoryBackend::IsFaviconBitmapDataEqual(
     FaviconBitmapID bitmap_id,
     const scoped_refptr<base::RefCountedMemory>& new_bitmap_data) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!new_bitmap_data)
     return false;
 
   scoped_refptr<base::RefCountedMemory> original_bitmap_data;
   thumbnail_db_->GetFaviconBitmap(bitmap_id, nullptr, nullptr,
                                   &original_bitmap_data, nullptr);
   return new_bitmap_data->Equals(original_bitmap_data);
 }
 
 bool HistoryBackend::GetFaviconsFromDB(
     const GURL& page_url,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(favicon_bitmap_results);
   favicon_bitmap_results->clear();
 
   if (!db_ || !thumbnail_db_)
     return false;
 
   // Time the query.
   TimeTicks beginning_time = TimeTicks::Now();
 
   // Get FaviconIDs for |page_url| and one of |icon_types|.
   std::vector<IconMapping> icon_mappings;
   thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_types,
                                            &icon_mappings);
   std::vector<favicon_base::FaviconID> favicon_ids;
   for (size_t i = 0; i < icon_mappings.size(); ++i)
     favicon_ids.push_back(icon_mappings[i].icon_id);
 
   // Populate |favicon_bitmap_results| and |icon_url_sizes|.
   bool success = GetFaviconBitmapResultsForBestMatch(favicon_ids, desired_sizes,
                                                      favicon_bitmap_results);
   UMA_HISTOGRAM_TIMES("History.GetFavIconFromDB",  // historical name
                       TimeTicks::Now() - beginning_time);
   return success && !favicon_bitmap_results->empty();
 }
 
 bool HistoryBackend::GetFaviconBitmapResultsForBestMatch(
     const std::vector<favicon_base::FaviconID>& candidate_favicon_ids,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   favicon_bitmap_results->clear();
 
   if (candidate_favicon_ids.empty())
     return true;
 
   // Find the FaviconID and the FaviconBitmapIDs which best match
   // |desired_size_in_dip| and |desired_scale_factors|.
   // TODO(pkotwicz): Select bitmap results from multiple favicons once
   // content::FaviconStatus supports multiple icon URLs.
   favicon_base::FaviconID best_favicon_id = 0;
@@ skipping 48 matching lines @@
     if (bitmap_result.is_valid())
       favicon_bitmap_results->push_back(bitmap_result);
   }
   return true;
 }
 
 bool HistoryBackend::SetFaviconMappingsForPageAndRedirects(
     const GURL& page_url,
     favicon_base::IconType icon_type,
     const std::vector<favicon_base::FaviconID>& icon_ids) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!thumbnail_db_)
     return false;
 
   // Find all the pages whose favicons we should set, we want to set it for
   // all the pages in the redirect chain if it redirected.
   RedirectList redirects;
   GetCachedRecentRedirects(page_url, &redirects);
   bool mappings_changed = SetFaviconMappingsForPages(redirects, icon_type,
                                                      icon_ids);
   if (page_url.has_ref()) {
     // Refs often gets added by Javascript, but the redirect chain is keyed to
     // the URL without a ref.
     GURL::Replacements replacements;
     replacements.ClearRef();
     GURL page_url_without_ref = page_url.ReplaceComponents(replacements);
     GetCachedRecentRedirects(page_url_without_ref, &redirects);
     mappings_changed |= SetFaviconMappingsForPages(redirects, icon_type,
                                                    icon_ids);
   }
 
   return mappings_changed;
 }
 
 bool HistoryBackend::SetFaviconMappingsForPages(
     const std::vector<GURL>& page_urls,
     favicon_base::IconType icon_type,
     const std::vector<favicon_base::FaviconID>& icon_ids) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   bool mappings_changed = false;
   for (auto i(page_urls.begin()); i != page_urls.end(); ++i) {
     mappings_changed |= SetFaviconMappingsForPage(*i, icon_type, icon_ids);
   }
   return mappings_changed;
 }
 
 bool HistoryBackend::SetFaviconMappingsForPage(
     const GURL& page_url,
     favicon_base::IconType icon_type,
     const std::vector<favicon_base::FaviconID>& icon_ids) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   DCHECK_LE(icon_ids.size(), kMaxFaviconsPerPage);
   bool mappings_changed = false;
 
   // Two icon types are considered 'equivalent' if one of the icon types is
   // TOUCH_ICON and the other is TOUCH_PRECOMPOSED_ICON.
   //
   // Sets the icon mappings from |page_url| for |icon_type| to the favicons
   // with |icon_ids|. Mappings for |page_url| to favicons of type |icon_type|
   // whose FaviconID is not in |icon_ids| are removed. All icon mappings for
   // |page_url| to favicons of a type equivalent to |icon_type| are removed.
@@ skipping 35 matching lines @@
 
   for (size_t i = 0; i < unmapped_icon_ids.size(); ++i) {
     thumbnail_db_->AddIconMapping(page_url, unmapped_icon_ids[i]);
     mappings_changed = true;
   }
   return mappings_changed;
 }
 
 void HistoryBackend::GetCachedRecentRedirects(const GURL& page_url,
                                               RedirectList* redirect_list) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   RedirectCache::iterator iter = recent_redirects_.Get(page_url);
   if (iter != recent_redirects_.end()) {
     *redirect_list = iter->second;
 
     // The redirect chain should have the destination URL as the last item.
     DCHECK(!redirect_list->empty());
     DCHECK_EQ(redirect_list->back(), page_url);
   } else {
     // No known redirects, construct mock redirect chain containing |page_url|.
     redirect_list->push_back(page_url);
   }
 }
 
 void HistoryBackend::SendFaviconChangedNotificationForPageAndRedirects(
     const GURL& page_url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   RedirectList redirect_list;
   GetCachedRecentRedirects(page_url, &redirect_list);
   if (!redirect_list.empty()) {
     std::set<GURL> favicons_changed(redirect_list.begin(),
                                        redirect_list.end());
     NotifyFaviconsChanged(favicons_changed, GURL());
   }
 }
 
 void HistoryBackend::SendFaviconChangedNotificationForIconURL(
     const GURL& icon_url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   NotifyFaviconsChanged(std::set<GURL>(), icon_url);
 }
 
 void HistoryBackend::Commit() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
 #if defined(OS_IOS)
   // Attempts to get the application running long enough to commit the database
   // transaction if it is currently being backgrounded.
   base::ios::ScopedCriticalAction scoped_critical_action;
 #endif
 
   // Note that a commit may not actually have been scheduled if a caller
@@ skipping 11 matching lines @@
 
   if (thumbnail_db_) {
     thumbnail_db_->CommitTransaction();
     DCHECK_EQ(thumbnail_db_->transaction_nesting(), 0)
         << "Somebody left a transaction open";
     thumbnail_db_->BeginTransaction();
   }
 }
 
 void HistoryBackend::ScheduleCommit() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (scheduled_commit_)
     return;
   scheduled_commit_ = new CommitLaterTask(this);
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CommitLaterTask::RunCommit, scheduled_commit_),
       base::TimeDelta::FromSeconds(kCommitIntervalSeconds));
 }
 
 void HistoryBackend::CancelScheduledCommit() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (scheduled_commit_) {
     scheduled_commit_->Cancel();
     scheduled_commit_ = nullptr;
   }
 }
 
 void HistoryBackend::ProcessDBTaskImpl() {
   if (!db_) {
     // db went away, release all the refs.
     queued_history_db_tasks_.clear();
@@ skipping 27 matching lines @@
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Generic operations
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void HistoryBackend::DeleteURLs(const std::vector<GURL>& urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   expirer_.DeleteURLs(urls);
 
   db_->GetStartDate(&first_recorded_time_);
   // Force a commit, if the user is deleting something for privacy reasons, we
   // want to get it on disk ASAP.
   Commit();
 }
 
 void HistoryBackend::DeleteURL(const GURL& url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   expirer_.DeleteURL(url);
 
   db_->GetStartDate(&first_recorded_time_);
   // Force a commit, if the user is deleting something for privacy reasons, we
   // want to get it on disk ASAP.
   Commit();
 }
 
 void HistoryBackend::ExpireHistoryBetween(const std::set<GURL>& restrict_urls,
                                           Time begin_time,
                                           Time end_time) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   if (begin_time.is_null() && (end_time.is_null() || end_time.is_max()) &&
       restrict_urls.empty()) {
     // Special case deleting all history so it can be faster and to reduce the
     // possibility of an information leak.
     DeleteAllHistory();
   } else {
     // Clearing parts of history, have the expirer do the depend
     expirer_.ExpireHistoryBetween(restrict_urls, begin_time, end_time);
 
     // Force a commit, if the user is deleting something for privacy reasons,
     // we want to get it on disk ASAP.
     Commit();
   }
 
   if (begin_time <= first_recorded_time_)
     db_->GetStartDate(&first_recorded_time_);
 }
 
 void HistoryBackend::ExpireHistoryForTimes(const std::set<base::Time>& times,
                                            base::Time begin_time,
                                            base::Time end_time) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (times.empty() || !db_)
     return;
 
   QueryOptions options;
   options.begin_time = begin_time;
   options.end_time = end_time;
   options.duplicate_policy = QueryOptions::KEEP_ALL_DUPLICATES;
   QueryResults results;
   QueryHistoryBasic(options, &results);
 
@@ skipping 27 matching lines @@
   Commit();
 
   DCHECK_GE(times_to_expire.back(), first_recorded_time_);
   // Update |first_recorded_time_| if we expired it.
   if (times_to_expire.back() == first_recorded_time_)
     db_->GetStartDate(&first_recorded_time_);
 }
 
 void HistoryBackend::ExpireHistory(
     const std::vector<ExpireHistoryArgs>& expire_list) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (db_) {
     bool update_first_recorded_time = false;
 
     for (std::vector<ExpireHistoryArgs>::const_iterator it =
              expire_list.begin();
          it != expire_list.end(); ++it) {
       expirer_.ExpireHistoryBetween(it->urls, it->begin_time, it->end_time);
 
       if (it->begin_time < first_recorded_time_)
         update_first_recorded_time = true;
     }
     Commit();
 
     // Update |first_recorded_time_| if any deletion might have affected it.
     if (update_first_recorded_time)
       db_->GetStartDate(&first_recorded_time_);
   }
 }
 
 void HistoryBackend::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!db_)
     return;
 
   for (std::set<GURL>::const_iterator i = urls.begin(); i != urls.end(); ++i) {
     VisitVector visits;
     URLRow url_row;
     if (db_->GetRowForURL(*i, &url_row))
       db_->GetVisitsForURL(url_row.id(), &visits);
     // We need to call DeleteURL() even if the DB didn't contain this URL, so
     // that we can delete all associated icons in the case of deleting an
     // unvisited bookmarked URL.
     if (visits.empty())
       expirer_.DeleteURL(*i);  // There are no more visits; nuke the URL.
   }
 }
 
 void HistoryBackend::DatabaseErrorCallback(int error, sql::Statement* stmt) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!scheduled_kill_db_ && sql::IsErrorCatastrophic(error)) {
     scheduled_kill_db_ = true;
 
     db_diagnostics_ = db_->GetDiagnosticInfo(error, stmt);
 
     // Don't just do the close/delete here, as we are being called by |db| and
     // that seems dangerous.
     // TODO(shess): Consider changing KillHistoryDatabase() to use
     // RazeAndClose().  Then it can be cleared immediately.
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&HistoryBackend::KillHistoryDatabase, this));
   }
 }
 
 void HistoryBackend::KillHistoryDatabase() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   scheduled_kill_db_ = false;
   if (!db_)
     return;
 
   // Rollback transaction because Raze() cannot be called from within a
   // transaction.
   db_->RollbackTransaction();
   bool success = db_->Raze();
   UMA_HISTOGRAM_BOOLEAN("History.KillHistoryDatabaseResult", success);
 
   // Release stashed embedder object before cleaning up the databases.
   supports_user_data_helper_.reset();
 
   // The expirer keeps tabs on the active databases. Tell it about the
   // databases which will be closed.
   expirer_.SetDatabases(nullptr, nullptr);
 
   // Reopen a new transaction for |db_| for the sake of CloseAllDatabases().
   db_->BeginTransaction();
   CloseAllDatabases();
 }
 
 base::SupportsUserData::Data* HistoryBackend::GetUserData(
     const void* key) const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(supports_user_data_helper_);
   return supports_user_data_helper_->GetUserData(key);
 }
 
 void HistoryBackend::SetUserData(const void* key,
                                  base::SupportsUserData::Data* data) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(supports_user_data_helper_);
   supports_user_data_helper_->SetUserData(key, data);
 }
 
 void HistoryBackend::ProcessDBTask(
     std::unique_ptr<HistoryDBTask> task,
     scoped_refptr<base::SingleThreadTaskRunner> origin_loop,
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled) {
   bool scheduled = !queued_history_db_tasks_.empty();
   queued_history_db_tasks_.push_back(base::MakeUnique<QueuedHistoryDBTask>(
       std::move(task), origin_loop, is_canceled));
   if (!scheduled)
     ProcessDBTaskImpl();
 }
 
 void HistoryBackend::NotifyFaviconsChanged(const std::set<GURL>& page_urls,
                                            const GURL& icon_url) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (delegate_)
     delegate_->NotifyFaviconsChanged(page_urls, icon_url);
 }
 
 void HistoryBackend::NotifyURLVisited(ui::PageTransition transition,
                                       const URLRow& row,
                                       const RedirectList& redirects,
                                       base::Time visit_time) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   for (HistoryBackendObserver& observer : observers_)
     observer.OnURLVisited(this, transition, row, redirects, visit_time);
 
   if (delegate_)
     delegate_->NotifyURLVisited(transition, row, redirects, visit_time);
 }
 
 void HistoryBackend::NotifyURLsModified(const URLRows& rows) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   for (HistoryBackendObserver& observer : observers_)
     observer.OnURLsModified(this, rows);
 
   if (delegate_)
     delegate_->NotifyURLsModified(rows);
 }
 
 void HistoryBackend::NotifyURLsDeleted(bool all_history,
                                        bool expired,
                                        const URLRows& rows,
                                        const std::set<GURL>& favicon_urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   URLRows copied_rows(rows);
   for (HistoryBackendObserver& observer : observers_) {
     observer.OnURLsDeleted(this, all_history, expired, copied_rows,
                            favicon_urls);
   }
 
   if (delegate_)
     delegate_->NotifyURLsDeleted(all_history, expired, copied_rows,
                                  favicon_urls);
 }
 
 // Deleting --------------------------------------------------------------------
 
 void HistoryBackend::DeleteAllHistory() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Our approach to deleting all history is:
   //  1. Copy the bookmarks and their dependencies to new tables with temporary
   //     names.
   //  2. Delete the original tables. Since tables can not share pages, we know
   //     that any data we don't want to keep is now in an unused page.
   //  3. Renaming the temporary tables to match the original.
   //  4. Vacuuming the database to delete the unused pages.
   //
   // Since we are likely to have very few bookmarks and their dependencies
   // compared to all history, this is also much faster than just deleting from
@@ skipping 36 matching lines @@
 
   db_->GetStartDate(&first_recorded_time_);
 
   // Send out the notification that history is cleared. The in-memory database
   // will pick this up and clear itself.
   NotifyURLsDeleted(true, false, URLRows(), std::set<GURL>());
 }
 
 bool HistoryBackend::ClearAllThumbnailHistory(
     const std::vector<GURL>& kept_urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   if (!thumbnail_db_) {
     // When we have no reference to the thumbnail database, maybe there was an
     // error opening it. In this case, we just try to blow it away to try to
     // fix the error if it exists. This may fail, in which case either the
     // file doesn't exist or there's no more we can do.
     sql::Connection::Delete(GetFaviconsFileName());
     return true;
   }
 
   // Isolate from any long-running transaction.
@@ skipping 18 matching lines @@
   // must be no transaction open on the table when we do this. We assume that
   // our long-running transaction is open, so we complete it and start it again.
   DCHECK_EQ(thumbnail_db_->transaction_nesting(), 1);
   thumbnail_db_->CommitTransaction();
   thumbnail_db_->Vacuum();
   thumbnail_db_->BeginTransaction();
   return true;
 }
 
 bool HistoryBackend::ClearAllMainHistory(const URLRows& kept_urls) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
   // Create the duplicate URL table. We will copy the kept URLs into this.
   if (!db_->CreateTemporaryURLTable())
     return false;
 
   // Insert the URLs into the temporary table.
   for (URLRows::const_iterator i = kept_urls.begin(); i != kept_urls.end();
        ++i) {
     db_->AddTemporaryURL(*i);
   }
 
   // Replace the original URL table with the temporary one.
   if (!db_->CommitTemporaryURLTable())
     return false;
 
   // Delete the old tables and recreate them empty.
   db_->RecreateAllTablesButURL();
 
   // Vacuum to reclaim the space from the dropped tables. This must be done
   // when there is no transaction open, and we assume that our long-running
   // transaction is currently open.
   db_->CommitTransaction();
   db_->Vacuum();
   db_->BeginTransaction();
   db_->GetStartDate(&first_recorded_time_);
 
   return true;
 }
 
 }  // namespace history