Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/extras/sqlite/sqlite_persistent_cookie_store.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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <iterator>
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 480 matching lines @@
   }
 
   PostBackgroundTask(
       FROM_HERE, base::Bind(&Backend::LoadKeyAndNotifyInBackground, this, key,
                             loaded_callback, base::Time::Now()));
 }
 
 void SQLitePersistentCookieStore::Backend::LoadAndNotifyInBackground(
     const LoadedCallback& loaded_callback,
     const base::Time& posted_at) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   IncrementTimeDelta increment(&cookie_load_duration_);
 
   UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.TimeLoadDBQueueWait",
                              base::Time::Now() - posted_at,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1), 50);
 
   if (!InitializeDatabase()) {
     PostClientTask(FROM_HERE, base::Bind(&Backend::CompleteLoadInForeground,
                                          this, loaded_callback, false));
   } else {
     ChainLoadCookies(loaded_callback);
   }
 }
 
 void SQLitePersistentCookieStore::Backend::LoadKeyAndNotifyInBackground(
     const std::string& key,
     const LoadedCallback& loaded_callback,
     const base::Time& posted_at) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   IncrementTimeDelta increment(&cookie_load_duration_);
 
   UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.TimeKeyLoadDBQueueWait",
                              base::Time::Now() - posted_at,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1), 50);
 
   bool success = false;
   if (InitializeDatabase()) {
     std::map<std::string, std::set<std::string>>::iterator it =
@@ skipping 17 matching lines @@
     const base::Closure& callback) {
   Commit();
   if (!callback.is_null())
     PostClientTask(FROM_HERE, callback);
 }
 
 void SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground(
     const LoadedCallback& loaded_callback,
     bool load_success,
     const ::Time& requested_at) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
 
   UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.TimeKeyLoadTotalWait",
                              base::Time::Now() - requested_at,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1), 50);
 
   Notify(loaded_callback, load_success);
 
   {
     base::AutoLock locked(metrics_lock_);
@@ skipping 38 matching lines @@
     bool load_success) {
   Notify(loaded_callback, load_success);
 
   if (load_success)
     ReportMetrics();
 }
 
 void SQLitePersistentCookieStore::Backend::Notify(
     const LoadedCallback& loaded_callback,
     bool load_success) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
 
   std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   {
     base::AutoLock locked(lock_);
     cookies.swap(cookies_);
   }
 
   loaded_callback.Run(std::move(cookies));
 }
 
 bool SQLitePersistentCookieStore::Backend::InitializeDatabase() {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   if (initialized_ || corruption_detected_) {
     // Return false if we were previously initialized but the DB has since been
     // closed, or if corruption caused a database reset during initialization.
     return db_ != NULL;
   }
 
   base::Time start = base::Time::Now();
 
   const base::FilePath dir = path_.DirName();
@@ skipping 82 matching lines @@
 
   initialized_ = true;
 
   if (!restore_old_session_cookies_)
     DeleteSessionCookiesOnStartup();
   return true;
 }
 
 void SQLitePersistentCookieStore::Backend::ChainLoadCookies(
     const LoadedCallback& loaded_callback) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   IncrementTimeDelta increment(&cookie_load_duration_);
 
   bool load_success = true;
 
   if (!db_) {
     // Close() has been called on this store.
     load_success = false;
   } else if (keys_to_load_.size() > 0) {
     // Load cookies for the first domain key.
     std::map<std::string, std::set<std::string>>::iterator it =
@@ skipping 14 matching lines @@
       LOG(WARNING) << "Failed to post task from " << FROM_HERE.ToString()
                    << " to background_task_runner_.";
     }
   } else {
     FinishedLoadingCookies(loaded_callback, load_success);
   }
 }
 
 bool SQLitePersistentCookieStore::Backend::LoadCookiesForDomains(
     const std::set<std::string>& domains) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   sql::Statement smt;
   if (restore_old_session_cookies_) {
     smt.Assign(db_->GetCachedStatement(
         SQL_FROM_HERE,
         "SELECT creation_utc, host_key, name, value, encrypted_value, path, "
         "expires_utc, secure, httponly, firstpartyonly, last_access_utc, "
         "has_expires, persistent, priority FROM cookies WHERE host_key = ?"));
   } else {
     smt.Assign(db_->GetCachedStatement(
@@ skipping 287 matching lines @@
   BatchOperation(PendingOperation::COOKIE_DELETE, cc);
 }
 
 void SQLitePersistentCookieStore::Backend::BatchOperation(
     PendingOperation::OperationType op,
     const CanonicalCookie& cc) {
   // Commit every 30 seconds.
   static const int kCommitIntervalMs = 30 * 1000;
   // Commit right away if we have more than 512 outstanding operations.
   static const size_t kCommitAfterBatchSize = 512;
-  DCHECK(!background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!background_task_runner_->RunsTasksInCurrentSequence());
 
   // We do a full copy of the cookie here, and hopefully just here.
   std::unique_ptr<PendingOperation> po(new PendingOperation(op, cc));
 
   PendingOperationsList::size_type num_pending;
   {
     base::AutoLock locked(lock_);
     pending_.push_back(po.release());
     num_pending = ++num_pending_;
   }
 
   if (num_pending == 1) {
     // We've gotten our first entry for this batch, fire off the timer.
     if (!background_task_runner_->PostDelayedTask(
             FROM_HERE, base::Bind(&Backend::Commit, this),
             base::TimeDelta::FromMilliseconds(kCommitIntervalMs))) {
       NOTREACHED() << "background_task_runner_ is not running.";
     }
   } else if (num_pending == kCommitAfterBatchSize) {
     // We've reached a big enough batch, fire off a commit now.
     PostBackgroundTask(FROM_HERE, base::Bind(&Backend::Commit, this));
   }
 }
 
 void SQLitePersistentCookieStore::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 82 matching lines @@
         break;
     }
   }
   bool succeeded = transaction.Commit();
   UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults",
                             succeeded ? 0 : 1, 2);
 }
 
 void SQLitePersistentCookieStore::Backend::Flush(
     const base::Closure& callback) {
-  DCHECK(!background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!background_task_runner_->RunsTasksInCurrentSequence());
   PostBackgroundTask(FROM_HERE, base::Bind(&Backend::FlushAndNotifyInBackground,
                                            this, callback));
 }
 
 // Fire off a close message to the background runner.  We could still have a
 // pending commit timer or Load operations holding references on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
 void SQLitePersistentCookieStore::Backend::Close(
     const base::Closure& callback) {
-  if (background_task_runner_->RunsTasksOnCurrentThread()) {
+  if (background_task_runner_->RunsTasksInCurrentSequence()) {
     InternalBackgroundClose(callback);
   } else {
     // Must close the backend on the background runner.
     PostBackgroundTask(FROM_HERE, base::Bind(&Backend::InternalBackgroundClose,
                                              this, callback));
   }
 }
 
 void SQLitePersistentCookieStore::Backend::InternalBackgroundClose(
     const base::Closure& callback) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   // Commit any pending operations
   Commit();
 
   meta_table_.Reset();
   db_.reset();
 
   // We're clean now.
   if (!callback.is_null())
     callback.Run();
 }
 
 void SQLitePersistentCookieStore::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;
 
   // Don't just do the close/delete here, as we are being called by |db| and
   // that seems dangerous.
   // 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.
   PostBackgroundTask(FROM_HERE, base::Bind(&Backend::KillDatabase, this));
 }
 
 void SQLitePersistentCookieStore::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 we will recreate
     // the database. Hopefully things go better then!
     bool success = db_->RazeAndClose();
     UMA_HISTOGRAM_BOOLEAN("Cookie.KillDatabaseResult", success);
     meta_table_.Reset();
     db_.reset();
   }
 }
 
 void SQLitePersistentCookieStore::Backend::DeleteAllInList(
     const std::list<CookieOrigin>& cookies) {
   if (cookies.empty())
     return;
 
-  if (background_task_runner_->RunsTasksOnCurrentThread()) {
+  if (background_task_runner_->RunsTasksInCurrentSequence()) {
     BackgroundDeleteAllInList(cookies);
   } else {
     // Perform deletion on background task runner.
     PostBackgroundTask(
         FROM_HERE,
         base::Bind(&Backend::BackgroundDeleteAllInList, this, cookies));
   }
 }
 
 void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnStartup() {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
   base::Time start_time = base::Time::Now();
   if (!db_->Execute("DELETE FROM cookies WHERE persistent != 1"))
     LOG(WARNING) << "Unable to delete session cookies.";
 
   UMA_HISTOGRAM_TIMES("Cookie.Startup.TimeSpentDeletingCookies",
                       base::Time::Now() - start_time);
   UMA_HISTOGRAM_COUNTS("Cookie.Startup.NumberOfCookiesDeleted",
                        db_->GetLastChangeCount());
 }
 
 void SQLitePersistentCookieStore::Backend::BackgroundDeleteAllInList(
     const std::list<CookieOrigin>& cookies) {
-  DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(background_task_runner_->RunsTasksInCurrentSequence());
 
   if (!db_)
     return;
 
   // Force a commit of any pending writes before issuing deletes.
   // TODO(rohitrao): Remove the need for this Commit() by instead pruning the
   // list of pending operations. https://crbug.com/486742.
   Commit();
 
   sql::Statement del_smt(db_->GetCachedStatement(
@@ skipping 121 matching lines @@
 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
   if (backend_)
     backend_->Flush(callback);
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   Close(base::Closure());
 }
 
 }  // namespace net