Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/chromeos/power/freezer_cgroup_process_manager.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 "chrome/browser/chromeos/power/freezer_cgroup_process_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 19 matching lines @@
 
 class FreezerCgroupProcessManager::FileWorker {
  public:
   // Called on UI thread.
   explicit FileWorker(scoped_refptr<base::SequencedTaskRunner> file_thread)
       : ui_thread_(content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::UI)),
         file_thread_(file_thread),
         enabled_(false),
         froze_successfully_(false) {
-    DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+    DCHECK(ui_thread_->RunsTasksInCurrentSequence());
   }
 
   // Called on FILE thread.
-  virtual ~FileWorker() { DCHECK(file_thread_->RunsTasksOnCurrentThread()); }
+  virtual ~FileWorker() { DCHECK(file_thread_->RunsTasksInCurrentSequence()); }
 
   void Start() {
-    DCHECK(file_thread_->RunsTasksOnCurrentThread());
+    DCHECK(file_thread_->RunsTasksInCurrentSequence());
 
     default_control_path_ = base::FilePath(kFreezerPath).Append(kCgroupProcs);
     to_be_frozen_control_path_ = base::FilePath(kFreezerPath)
                                      .AppendASCII(kToBeFrozen)
                                      .AppendASCII(kCgroupProcs);
     to_be_frozen_state_path_ = base::FilePath(kFreezerPath)
                                    .AppendASCII(kToBeFrozen)
                                    .AppendASCII(kFreezerState);
     enabled_ = base::PathIsWritable(default_control_path_) &&
                base::PathIsWritable(to_be_frozen_control_path_) &&
                base::PathIsWritable(to_be_frozen_state_path_);
 
     if (!enabled_) {
       LOG(WARNING) << "Cgroup freezer does not exist or is not writable. "
                    << "Unable to freeze renderer processes.";
     }
   }
 
   void SetShouldFreezeRenderer(base::ProcessHandle handle, bool frozen) {
-    DCHECK(file_thread_->RunsTasksOnCurrentThread());
+    DCHECK(file_thread_->RunsTasksInCurrentSequence());
 
     WriteCommandToFile(base::IntToString(handle),
                        frozen ? to_be_frozen_control_path_
                               : default_control_path_);
   }
 
   void FreezeRenderers() {
-    DCHECK(file_thread_->RunsTasksOnCurrentThread());
+    DCHECK(file_thread_->RunsTasksInCurrentSequence());
 
     if (!enabled_) {
       LOG(ERROR) << "Attempting to freeze renderers when the freezer cgroup is "
                  << "not available.";
       return;
     }
 
     froze_successfully_ =
         WriteCommandToFile(kFreezeCommand, to_be_frozen_state_path_);
   }
 
   void ThawRenderers(ResultCallback callback) {
-    DCHECK(file_thread_->RunsTasksOnCurrentThread());
+    DCHECK(file_thread_->RunsTasksInCurrentSequence());
 
     if (!enabled_) {
       LOG(ERROR) << "Attempting to thaw renderers when the freezer cgroup is "
                  << "not available.";
       return;
     }
 
     bool result = WriteCommandToFile(kThawCommand, to_be_frozen_state_path_);
 
     // TODO(derat): For now, lie and report success if thawing failed but
     // freezing also failed previously. Remove after weird EBADF and ENOENT
     // problems tracked at http://crbug.com/661310 are fixed.
     if (!result && !froze_successfully_)
       result = true;
 
     ui_thread_->PostTask(FROM_HERE, base::Bind(callback, result));
   }
 
   void CheckCanFreezeRenderers(ResultCallback callback) {
-    DCHECK(file_thread_->RunsTasksOnCurrentThread());
+    DCHECK(file_thread_->RunsTasksInCurrentSequence());
 
     ui_thread_->PostTask(FROM_HERE, base::Bind(callback, enabled_));
   }
 
  private:
   bool WriteCommandToFile(const std::string& command,
                           const base::FilePath& file) {
     int bytes = base::WriteFile(file, command.c_str(), command.size());
     if (bytes == -1) {
       PLOG(ERROR) << "Writing " << command << " to " << file.value()
@@ skipping 63 matching lines @@
 
 void FreezerCgroupProcessManager::CheckCanFreezeRenderers(
     ResultCallback callback) {
   file_thread_->PostTask(FROM_HERE,
                          base::Bind(&FileWorker::CheckCanFreezeRenderers,
                                     base::Unretained(file_worker_.get()),
                                     callback));
 }
 
 }  // namespace chromeos