Use OnceCallback in PrinterQuery::SetSettings.

Bug: 625126
Change-Id: I8929c0fa1825b6175dd9a92284aabc4ff4983461
Reviewed-on: https://chromium-review.googlesource.com/907548Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Vladislav Kuzkokov <vkuzkokov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#536077}

chrome/browser/printing/print_job.cc

@@ -34,9 +34,9 @@ using base::TimeDelta;
 namespace printing {
 
 // Helper function to ensure |owner| is valid until at least |callback| returns.
-void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
-                     const base::Closure& callback) {
-  callback.Run();
+void HoldRefCallback(scoped_refptr<PrintJobWorkerOwner> owner,
+                     base::OnceClosure callback) {
+  std::move(callback).Run();
 }
 
 PrintJob::PrintJob()
@@ -124,11 +124,11 @@ void PrintJob::StartPrinting() {
   }
 
   // Real work is done in PrintJobWorker::StartPrinting().
-  worker_->PostTask(FROM_HERE,
-                    base::Bind(&HoldRefCallback, base::WrapRefCounted(this),
-                               base::Bind(&PrintJobWorker::StartPrinting,
-                                          base::Unretained(worker_.get()),
-                                          base::RetainedRef(document_))));
+  worker_->PostTask(
+      FROM_HERE, base::BindOnce(&HoldRefCallback, base::WrapRefCounted(this),
+                                base::BindOnce(&PrintJobWorker::StartPrinting,
+                                               base::Unretained(worker_.get()),
+                                               base::RetainedRef(document_))));
   // Set the flag right now.
   is_job_pending_ = true;
 
@@ -352,11 +352,12 @@ void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (worker_) {
     DCHECK(!is_job_pending_);
     // Sync the document with the worker.
-    worker_->PostTask(FROM_HERE,
-                      base::Bind(&HoldRefCallback, base::WrapRefCounted(this),
-                                 base::Bind(&PrintJobWorker::OnDocumentChanged,
-                                            base::Unretained(worker_.get()),
-                                            base::RetainedRef(document_))));
+    worker_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&HoldRefCallback, base::WrapRefCounted(this),
+                       base::BindOnce(&PrintJobWorker::OnDocumentChanged,
+                                      base::Unretained(worker_.get()),
+                                      base::RetainedRef(document_))));
   }
 }
 

chrome/browser/printing/print_job.h

@@ -31,8 +31,8 @@ class PrintedPage;
 #endif
 class PrinterQuery;
 
-void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
-                     const base::Closure& callback);
+void HoldRefCallback(scoped_refptr<PrintJobWorkerOwner> owner,
+                     base::OnceClosure callback);
 
 // Manages the print work for a specific document. Talks to the printer through
 // PrintingContext through PrintJobWorker. Hides access to PrintingContext in a

chrome/browser/printing/print_job_manager.cc

@@ -61,7 +61,8 @@ void PrintQueriesQueue::Shutdown() {
   // corresponding PrintJob, so any pending preview requests are not covered
   // by PrintJobManager::StopJobs and should be stopped explicitly.
   for (auto& query : queries_to_stop) {
-    query->PostTask(FROM_HERE, base::Bind(&PrinterQuery::StopWorker, query));
+    query->PostTask(FROM_HERE,
+                    base::BindOnce(&PrinterQuery::StopWorker, query));
   }
 }
 

chrome/browser/printing/print_job_worker.cc

@@ -102,11 +102,11 @@ void NotificationCallback(PrintJobWorkerOwner* print_job,
       content::Details<JobEventDetails>(details));
 }
 
-void PostOnOwnerThread(const scoped_refptr<PrintJobWorkerOwner>& owner,
-                       const PrintingContext::PrintSettingsCallback& callback,
+void PostOnOwnerThread(scoped_refptr<PrintJobWorkerOwner> owner,
+                       PrintingContext::PrintSettingsCallback callback,
                        PrintingContext::Result result) {
-  owner->PostTask(FROM_HERE, base::Bind(&HoldRefCallback, owner,
-                                        base::Bind(callback, result)));
+  owner->PostTask(FROM_HERE, base::BindOnce(&HoldRefCallback, owner,
+                                            base::BindOnce(callback, result)));
 }
 
 #if defined(OS_WIN)
@@ -178,16 +178,17 @@ void PrintJobWorker::GetSettings(bool ask_user_for_settings,
   if (ask_user_for_settings) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::BindOnce(&HoldRefCallback, base::WrapRefCounted(owner_),
-                       base::Bind(&PrintJobWorker::GetSettingsWithUI,
-                                  base::Unretained(this), document_page_count,
-                                  has_selection, is_scripted)));
+        base::BindOnce(
+            &HoldRefCallback, base::WrapRefCounted(owner_),
+            base::BindOnce(&PrintJobWorker::GetSettingsWithUI,
+                           base::Unretained(this), document_page_count,
+                           has_selection, is_scripted)));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::BindOnce(&HoldRefCallback, base::WrapRefCounted(owner_),
-                       base::Bind(&PrintJobWorker::UseDefaultSettings,
-                                  base::Unretained(this))));
+                       base::BindOnce(&PrintJobWorker::UseDefaultSettings,
+                                      base::Unretained(this))));
   }
 }
 
@@ -199,8 +200,8 @@ void PrintJobWorker::SetSettings(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &HoldRefCallback, base::WrapRefCounted(owner_),
-          base::Bind(&PrintJobWorker::UpdatePrintSettings,
-                     base::Unretained(this), base::Passed(&new_settings))));
+          base::BindOnce(&PrintJobWorker::UpdatePrintSettings,
+                         base::Unretained(this), std::move(new_settings))));
 }
 
 void PrintJobWorker::UpdatePrintSettings(
@@ -223,9 +224,9 @@ void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
 
   // PrintJob will create the new PrintedDocument.
   owner_->PostTask(FROM_HERE,
-                   base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
-                              base::WrapRefCounted(owner_),
-                              printing_context_->settings(), result));
+                   base::BindOnce(&PrintJobWorkerOwner::GetSettingsDone,
+                                  base::WrapRefCounted(owner_),
+                                  printing_context_->settings(), result));
 }
 
 void PrintJobWorker::GetSettingsWithUI(
@@ -391,9 +392,9 @@ bool PrintJobWorker::IsRunning() const {
 }
 
 bool PrintJobWorker::PostTask(const base::Location& from_here,
-                              const base::Closure& task) {
+                              base::OnceClosure task) {
   if (task_runner_.get())
-    return task_runner_->PostTask(from_here, task);
+    return task_runner_->PostTask(from_here, std::move(task));
   return false;
 }
 
@@ -422,10 +423,10 @@ void PrintJobWorker::OnDocumentDone() {
     return;
   }
 
-  owner_->PostTask(FROM_HERE,
-                   base::Bind(&NotificationCallback, base::RetainedRef(owner_),
-                              JobEventDetails::DOC_DONE, job_id,
-                              base::RetainedRef(document_)));
+  owner_->PostTask(FROM_HERE, base::BindOnce(&NotificationCallback,
+                                             base::RetainedRef(owner_),
+                                             JobEventDetails::DOC_DONE, job_id,
+                                             base::RetainedRef(document_)));
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
@@ -473,8 +474,8 @@ void PrintJobWorker::OnFailure() {
   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 
   owner_->PostTask(
-      FROM_HERE, base::BindRepeating(
-                     &NotificationCallback, base::RetainedRef(owner_),
+      FROM_HERE,
+      base::BindOnce(&NotificationCallback, base::RetainedRef(owner_),
                      JobEventDetails::FAILED, 0, base::RetainedRef(document_)));
   Cancel();
 

chrome/browser/printing/print_job_worker.h

@@ -76,7 +76,7 @@ class PrintJobWorker {
   bool IsRunning() const;
 
   // Posts the given task to be run.
-  bool PostTask(const base::Location& from_here, const base::Closure& task);
+  bool PostTask(const base::Location& from_here, base::OnceClosure task);
 
   // Signals the thread to exit in the near future.
   void StopSoon();

chrome/browser/printing/print_job_worker_owner.cc

@@ -21,8 +21,8 @@ bool PrintJobWorkerOwner::RunsTasksInCurrentSequence() const {
 }
 
 bool PrintJobWorkerOwner::PostTask(const base::Location& from_here,
-                                   const base::Closure& task) {
-  return task_runner_->PostTask(from_here, task);
+                                   base::OnceClosure task) {
+  return task_runner_->PostTask(from_here, std::move(task));
 }
 
 }  // namespace printing

chrome/browser/printing/print_job_worker_owner.h

@@ -47,7 +47,7 @@ class PrintJobWorkerOwner
   bool RunsTasksInCurrentSequence() const;
 
   // Posts the given task to be run.
-  bool PostTask(const base::Location& from_here, const base::Closure& task);
+  bool PostTask(const base::Location& from_here, base::OnceClosure task);
 
  protected:
   friend class base::RefCountedThreadSafe<PrintJobWorkerOwner>;

chrome/browser/printing/printer_query.cc

@@ -93,10 +93,9 @@ void PrinterQuery::SetSettings(
     base::OnceClosure callback) {
   StartWorker(std::move(callback));
 
-  worker_->PostTask(FROM_HERE,
-                    base::Bind(&PrintJobWorker::SetSettings,
-                               base::Unretained(worker_.get()),
-                               base::Passed(&new_settings)));
+  worker_->PostTask(FROM_HERE, base::BindOnce(&PrintJobWorker::SetSettings,
+                                              base::Unretained(worker_.get()),
+                                              std::move(new_settings)));
 }
 
 void PrinterQuery::StartWorker(base::OnceClosure callback) {