Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/printing/print_job.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 "chrome/browser/printing/print_job.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
   DCHECK(base::MessageLoopForUI::IsCurrent() ||
          base::MessageLoop::current()->type() ==
              base::MessageLoop::TYPE_DEFAULT);
 }
 
 PrintJob::~PrintJob() {
   // The job should be finished (or at least canceled) when it is destroyed.
   DCHECK(!is_job_pending_);
   DCHECK(!is_canceling_);
   DCHECK(!worker_ || !worker_->IsRunning());
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
 }
 
 void PrintJob::Initialize(PrintJobWorkerOwner* job,
                           PrintedPagesSource* source,
                           int page_count) {
   DCHECK(!source_);
   DCHECK(!worker_);
   DCHECK(!is_job_pending_);
   DCHECK(!is_canceling_);
   DCHECK(!document_.get());
@@ skipping 10 matching lines @@
   UpdatePrintedDocument(new_doc);
 
   // Don't forget to register to our own messages.
   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                  content::Source<PrintJob>(this));
 }
 
 void PrintJob::Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
   DCHECK_EQ(chrome::NOTIFICATION_PRINT_JOB_EVENT, type);
 
   OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
 }
 
 void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
                                PrintingContext::Result result) {
   NOTREACHED();
 }
 
 std::unique_ptr<PrintJobWorker> PrintJob::DetachWorker(
     PrintJobWorkerOwner* new_owner) {
   NOTREACHED();
   return nullptr;
 }
 
 const PrintSettings& PrintJob::settings() const {
   return settings_;
 }
 
 int PrintJob::cookie() const {
   // Always use an invalid cookie in this case.
   if (!document_.get())
     return 0;
   return document_->cookie();
 }
 
 void PrintJob::StartPrinting() {
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
   if (!worker_->IsRunning() || is_job_pending_) {
     NOTREACHED();
     return;
   }
 
   // Real work is done in PrintJobWorker::StartPrinting().
   worker_->PostTask(FROM_HERE,
                     base::Bind(&HoldRefCallback, make_scoped_refptr(this),
                                base::Bind(&PrintJobWorker::StartPrinting,
                                           base::Unretained(worker_.get()),
                                           base::RetainedRef(document_))));
   // Set the flag right now.
   is_job_pending_ = true;
 
   // Tell everyone!
   scoped_refptr<JobEventDetails> details(new JobEventDetails(
       JobEventDetails::NEW_DOC, 0, document_.get(), nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::Stop() {
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
 
   if (quit_factory_.HasWeakPtrs()) {
     // In case we're running a nested run loop to wait for a job to finish,
     // and we finished before the timeout, quit the nested loop right away.
     Quit();
     quit_factory_.InvalidateWeakPtrs();
   }
 
   // Be sure to live long enough.
   scoped_refptr<PrintJob> handle(this);
 
   if (worker_->IsRunning()) {
     ControlledWorkerShutdown();
   } else {
     // Flush the cached document.
     is_job_pending_ = false;
     UpdatePrintedDocument(nullptr);
   }
 }
 
 void PrintJob::Cancel() {
   if (is_canceling_)
     return;
   is_canceling_ = true;
 
   // Be sure to live long enough.
   scoped_refptr<PrintJob> handle(this);
 
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
   if (worker_ && worker_->IsRunning()) {
     // Call this right now so it renders the context invalid. Do not use
     // InvokeLater since it would take too much time.
     worker_->Cancel();
   }
   // Make sure a Cancel() is broadcast.
   scoped_refptr<JobEventDetails> details(
       new JobEventDetails(JobEventDetails::FAILED, 0, nullptr, nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
@@ skipping 221 matching lines @@
 
   scoped_refptr<JobEventDetails> details(new JobEventDetails(
       JobEventDetails::JOB_DONE, 0, document_.get(), nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::ControlledWorkerShutdown() {
-  DCHECK(RunsTasksOnCurrentThread());
+  DCHECK(RunsTasksInCurrentSequence());
 
   // The deadlock this code works around is specific to window messaging on
   // Windows, so we aren't likely to need it on any other platforms.
 #if defined(OS_WIN)
   // We could easily get into a deadlock case if worker_->Stop() is used; the
   // printer driver created a window as a child of the browser window. By
   // canceling the job, the printer driver initiated dialog box is destroyed,
   // which sends a blocking message to its parent window. If the browser window
   // thread is not processing messages, a deadlock occurs.
   //
@@ skipping 44 matching lines @@
     : document_(document), page_(page), type_(type), job_id_(job_id) {}
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing