Rename TaskRunner::RunsTasksOnCurrentThread() in //content

content/browser/browser_thread_impl.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 "content/browser/browser_thread_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/atomicops.h"
@@ skipping 115 matching lines @@
                                           "BrowserBlocking",
                                           base::TaskPriority::USER_VISIBLE)) {}
 
   // This lock protects |task_runners| and |states|. Do not read or modify those
   // arrays without holding this lock. Do not block while holding this lock.
   base::Lock lock;
 
   // This array is filled either as the underlying threads start and invoke
   // Init() or in RedirectThreadIDToTaskRunner() for threads that are being
   // redirected. It is not emptied during shutdown in order to support
-  // RunsTasksOnCurrentThread() until the very end.
+  // RunsTasksInCurrentSequence() until the very end.
   scoped_refptr<base::SingleThreadTaskRunner>
       task_runners[BrowserThread::ID_COUNT];
 
   // Holds the state of each BrowserThread::ID.
   BrowserThreadState states[BrowserThread::ID_COUNT] = {};
 
   // Only atomic operations are used on this pointer. The delegate isn't owned
   // by BrowserThreadGlobals, rather by whoever calls
   // BrowserThread::SetIOThreadDelegate.
   BrowserThreadDelegateAtomicPtr io_thread_delegate = 0;
@@ skipping 54 matching lines @@
 
 #if DCHECK_IS_ON()
   {
     base::AutoLock lock(globals.lock);
     // |globals| should already have been initialized for |identifier_| in
     // BrowserThreadImpl::StartWithOptions(). If this isn't the case it's likely
     // because this BrowserThreadImpl's owner incorrectly used Thread::Start.*()
     // instead of BrowserThreadImpl::Start.*().
     DCHECK_EQ(globals.states[identifier_], BrowserThreadState::RUNNING);
     DCHECK(globals.task_runners[identifier_]);
-    DCHECK(globals.task_runners[identifier_]->RunsTasksOnCurrentThread());
+    DCHECK(globals.task_runners[identifier_]->RunsTasksInCurrentSequence());
   }
 #endif  // DCHECK_IS_ON()
 
   if (identifier_ == BrowserThread::DB ||
       identifier_ == BrowserThread::FILE ||
       identifier_ == BrowserThread::FILE_USER_BLOCKING ||
       identifier_ == BrowserThread::PROCESS_LAUNCHER ||
       identifier_ == BrowserThread::CACHE) {
     // Nesting and task observers are not allowed on redirected threads.
     base::RunLoop::DisallowNestingOnCurrentThread();
@@ skipping 345 matching lines @@
          globals.states[identifier] == BrowserThreadState::RUNNING;
 }
 
 // static
 bool BrowserThread::CurrentlyOn(ID identifier) {
   BrowserThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
   DCHECK_GE(identifier, 0);
   DCHECK_LT(identifier, ID_COUNT);
   return globals.task_runners[identifier] &&
-         globals.task_runners[identifier]->RunsTasksOnCurrentThread();
+         globals.task_runners[identifier]->RunsTasksInCurrentSequence();
 }
 
 // static
 std::string BrowserThread::GetDCheckCurrentlyOnErrorMessage(ID expected) {
   std::string actual_name = base::PlatformThread::GetName();
   if (actual_name.empty())
     actual_name = "Unknown Thread";
 
   std::string result = "Must be called on ";
   result += GetThreadName(expected);
@@ skipping 66 matching lines @@
     return false;
 
   BrowserThreadGlobals& globals = g_globals.Get();
   // Profiler to track potential contention on |globals.lock|. This only does
   // real work on canary and local dev builds, so the cost of having this here
   // should be minimal.
   tracked_objects::ScopedTracker tracking_profile(FROM_HERE);
   base::AutoLock lock(globals.lock);
   for (int i = 0; i < ID_COUNT; ++i) {
     if (globals.task_runners[i] &&
-        globals.task_runners[i]->RunsTasksOnCurrentThread()) {
+        globals.task_runners[i]->RunsTasksInCurrentSequence()) {
       *identifier = static_cast<ID>(i);
       return true;
     }
   }
 
   return false;
 }
 
 // static
 scoped_refptr<base::SingleThreadTaskRunner>
 BrowserThread::GetTaskRunnerForThread(ID identifier) {
   return g_task_runners.Get().proxies[identifier];
 }
 
 // static
 void BrowserThread::SetIOThreadDelegate(BrowserThreadDelegate* delegate) {
   BrowserThreadGlobals& globals = g_globals.Get();
   BrowserThreadDelegateAtomicPtr old_delegate =
       base::subtle::NoBarrier_AtomicExchange(
           &globals.io_thread_delegate,
           reinterpret_cast<BrowserThreadDelegateAtomicPtr>(delegate));
 
   // This catches registration when previously registered.
   DCHECK(!delegate || !old_delegate);
 }
 
 }  // namespace content