Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/printing/print_job_worker.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_worker.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
                                         base::Bind(callback, result)));
 }
 
 }  // namespace
 
 PrintJobWorker::PrintJobWorker(int render_process_id,
                                int render_frame_id,
                                PrintJobWorkerOwner* owner)
     : owner_(owner), thread_("Printing_Worker"), weak_factory_(this) {
   // The object is created in the IO thread.
-  DCHECK(owner_->RunsTasksOnCurrentThread());
+  DCHECK(owner_->RunsTasksInCurrentSequence());
 
   printing_context_delegate_ = base::MakeUnique<PrintingContextDelegate>(
       render_process_id, render_frame_id);
   printing_context_ = PrintingContext::Create(printing_context_delegate_.get());
 }
 
 PrintJobWorker::~PrintJobWorker() {
   // The object is normally deleted in the UI thread, but when the user
   // cancels printing or in the case of print preview, the worker is destroyed
   // on the I/O thread.
-  DCHECK(owner_->RunsTasksOnCurrentThread());
+  DCHECK(owner_->RunsTasksInCurrentSequence());
   Stop();
 }
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
 void PrintJobWorker::GetSettings(bool ask_user_for_settings,
                                  int document_page_count,
                                  bool has_selection,
                                  MarginType margin_type,
                                  bool is_scripted,
                                  bool is_modifiable) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
   // Recursive task processing is needed for the dialog in case it needs to be
   // destroyed by a task.
   // TODO(thestig): This code is wrong. SetNestableTasksAllowed(true) is needed
   // on the thread where the PrintDlgEx is called, and definitely both calls
   // should happen on the same thread. See http://crbug.com/73466
   // MessageLoop::current()->SetNestableTasksAllowed(true);
   printing_context_->set_margin_type(margin_type);
   printing_context_->set_is_modifiable(is_modifiable);
@@ skipping 11 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::BindOnce(&HoldRefCallback, make_scoped_refptr(owner_),
                        base::Bind(&PrintJobWorker::UseDefaultSettings,
                                   base::Unretained(this))));
   }
 }
 
 void PrintJobWorker::SetSettings(
     std::unique_ptr<base::DictionaryValue> new_settings) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &HoldRefCallback, make_scoped_refptr(owner_),
           base::Bind(&PrintJobWorker::UpdatePrintSettings,
                      base::Unretained(this), base::Passed(&new_settings))));
 }
 
 void PrintJobWorker::UpdatePrintSettings(
@@ skipping 52 matching lines @@
                  base::Bind(&PrintJobWorker::GetSettingsDone,
                             weak_factory_.GetWeakPtr())));
 }
 
 void PrintJobWorker::UseDefaultSettings() {
   PrintingContext::Result result = printing_context_->UseDefaultSettings();
   GetSettingsDone(result);
 }
 
 void PrintJobWorker::StartPrinting(PrintedDocument* new_document) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK_EQ(document_.get(), new_document);
   DCHECK(document_.get());
 
   if (!document_.get() || page_number_ != PageNumber::npos() ||
       document_.get() != new_document) {
     return;
   }
 
   base::string16 document_name = SimplifyDocumentTitle(document_->name());
@@ skipping 11 matching lines @@
   // Try to print already cached data. It may already have been generated for
   // the print preview.
   OnNewPage();
   // Don't touch this anymore since the instance could be destroyed. It happens
   // if all the pages are printed a one sweep and the client doesn't have a
   // handle to us anymore. There's a timing issue involved between the worker
   // thread and the UI thread. Take no chance.
 }
 
 void PrintJobWorker::OnDocumentChanged(PrintedDocument* new_document) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
   if (page_number_ != PageNumber::npos())
     return;
 
   document_ = new_document;
 }
 
 void PrintJobWorker::OnNewPage() {
   if (!document_.get())  // Spurious message.
     return;
 
   // message_loop() could return NULL when the print job is cancelled.
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   if (page_number_ == PageNumber::npos()) {
     // Find first page to print.
     int page_count = document_->page_count();
     if (!page_count) {
       // We still don't know how many pages the document contains. We can't
       // start to print the document yet since the header/footer may refer to
       // the document's page count.
       return;
     }
@@ skipping 51 matching lines @@
   thread_.Stop();
 }
 
 bool PrintJobWorker::Start() {
   bool result = thread_.Start();
   task_runner_ = thread_.task_runner();
   return result;
 }
 
 void PrintJobWorker::OnDocumentDone() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
 
   int job_id = printing_context_->job_id();
   if (printing_context_->DocumentDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   owner_->PostTask(FROM_HERE,
                    base::Bind(&NotificationCallback, base::RetainedRef(owner_),
                               JobEventDetails::DOC_DONE, job_id,
                               base::RetainedRef(document_), nullptr));
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
 }
 
 void PrintJobWorker::SpoolPage(PrintedPage* page) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_NE(page_number_, PageNumber::npos());
 
   // Signal everyone that the page is about to be printed.
   owner_->PostTask(
       FROM_HERE,
       base::Bind(&NotificationCallback, base::RetainedRef(owner_),
                  JobEventDetails::NEW_PAGE, printing_context_->job_id(),
                  base::RetainedRef(document_), base::RetainedRef(page)));
 
   // Preprocess.
@@ skipping 17 matching lines @@
 
   // Signal everyone that the page is printed.
   owner_->PostTask(
       FROM_HERE,
       base::Bind(&NotificationCallback, base::RetainedRef(owner_),
                  JobEventDetails::PAGE_DONE, printing_context_->job_id(),
                  base::RetainedRef(document_), base::RetainedRef(page)));
 }
 
 void PrintJobWorker::OnFailure() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // We may loose our last reference by broadcasting the FAILED event.
   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 
   owner_->PostTask(FROM_HERE,
                    base::Bind(&NotificationCallback, base::RetainedRef(owner_),
                               JobEventDetails::FAILED, 0,
                               base::RetainedRef(document_), nullptr));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing