Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/extras/sqlite/sqlite_channel_id_store.cc

 // Copyright 2014 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 "net/extras/sqlite/sqlite_channel_id_store.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 179 matching lines @@
 
   background_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&Backend::LoadInBackground, this, channel_ids_ptr),
       base::Bind(loaded_callback, base::Passed(&channel_ids)));
 }
 
 void SQLiteChannelIDStore::Backend::LoadInBackground(
     std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>*
         channel_ids) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   // This method should be called only once per instance.
   DCHECK(!db_.get());
 
   base::TimeTicks start = base::TimeTicks::Now();
 
   // Ensure the parent directory for storing certs is created before reading
   // from it.
   const base::FilePath dir = path_.DirName();
   if (!base::PathExists(dir) && !base::CreateDirectory(dir)) {
@@ skipping 210 matching lines @@
   transaction.Commit();
 
   // Put future migration cases here.
 
   return true;
 }
 
 void SQLiteChannelIDStore::Backend::DatabaseErrorCallback(
     int error,
     sql::Statement* stmt) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   if (!sql::IsErrorCatastrophic(error))
     return;
 
   // TODO(shess): Running KillDatabase() multiple times should be
   // safe.
   if (corruption_detected_)
     return;
 
   corruption_detected_ = true;
 
   // TODO(shess): Consider just calling RazeAndClose() immediately.
   // db_ may not be safe to reset at this point, but RazeAndClose()
   // would cause the stack to unwind safely with errors.
   background_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&Backend::KillDatabase, this));
 }
 
 void SQLiteChannelIDStore::Backend::KillDatabase() {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   if (db_) {
     // This Backend will now be in-memory only. In a future run the database
     // will be recreated. Hopefully things go better then!
     bool success = db_->RazeAndClose();
     UMA_HISTOGRAM_BOOLEAN("DomainBoundCerts.KillDatabaseResult", success);
     meta_table_.Reset();
     db_.reset();
   }
 }
@@ skipping 45 matching lines @@
         base::TimeDelta::FromMilliseconds(kCommitIntervalMs));
   } else if (num_pending == kCommitAfterBatchSize) {
     // We've reached a big enough batch, fire off a commit now.
     background_task_runner_->PostTask(FROM_HERE,
                                       base::Bind(&Backend::Commit, this));
   }
 }
 
 void SQLiteChannelIDStore::Backend::PrunePendingOperationsForDeletes(
     const std::list<std::string>& server_identifiers) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   base::AutoLock locked(lock_);
 
   for (PendingOperationsList::iterator it = pending_.begin();
        it != pending_.end();) {
     bool remove =
         std::find(server_identifiers.begin(), server_identifiers.end(),
                   (*it)->channel_id().server_identifier()) !=
         server_identifiers.end();
 
     if (remove) {
       std::unique_ptr<PendingOperation> po(*it);
       it = pending_.erase(it);
       --num_pending_;
     } else {
       ++it;
     }
   }
 }
 
 void SQLiteChannelIDStore::Backend::Flush() {
   background_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&Backend::Commit, this));
 }
 
 void SQLiteChannelIDStore::Backend::Commit() {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   PendingOperationsList ops;
   {
     base::AutoLock locked(lock_);
     pending_.swap(ops);
     num_pending_ = 0;
   }
 
   // Maybe an old timer fired or we are already Close()'ed.
   if (!db_.get() || ops.empty())
@@ skipping 52 matching lines @@
 // Fire off a close message to the background task runner. We could still have a
 // pending commit timer that will be holding a reference on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
 void SQLiteChannelIDStore::Backend::Close() {
   // Must close the backend on the background task runner.
   background_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Backend::InternalBackgroundClose, this));
 }
 
 void SQLiteChannelIDStore::Backend::InternalBackgroundClose() {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   // Commit any pending operations
   Commit();
   db_.reset();
 }
 
 void SQLiteChannelIDStore::Backend::BackgroundDeleteAllInList(
     const std::list<std::string>& server_identifiers) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   if (!db_.get())
     return;
 
   PrunePendingOperationsForDeletes(server_identifiers);
 
   sql::Statement del_smt(db_->GetCachedStatement(
       SQL_FROM_HERE, "DELETE FROM channel_id WHERE host=?"));
   if (!del_smt.is_valid()) {
     LOG(WARNING) << "Unable to delete channel ids.";
@@ skipping 57 matching lines @@
   backend_->Flush();
 }
 
 SQLiteChannelIDStore::~SQLiteChannelIDStore() {
   backend_->Close();
   // We release our reference to the Backend, though it will probably still have
   // a reference if the background task runner has not run Close() yet.
 }
 
 }  // namespace net