base::Bind: Convert (again) chrome/browser/printing.

chrome/browser/printing/print_job_worker.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 15 matching lines @@
 // Helper function to ensure |owner| is valid until at least |callback| returns.
 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
                      const base::Closure& callback) {
   callback.Run();
 }
 
 }  // namespace
 
 namespace printing {
 
-class PrintJobWorker::NotificationTask : public Task {
- public:
-  NotificationTask() : print_job_(NULL), details_(NULL) {}
-  ~NotificationTask() {}
-
-  // Initializes the object. This object can't be initialized in the constructor
-  // since it is not created directly.
-  void Init(PrintJobWorkerOwner* print_job,
-            JobEventDetails::Type detail_type,
-            PrintedDocument* document,
-            PrintedPage* page) {
-    DCHECK(!print_job_);
-    DCHECK(!details_);
-    print_job_ = print_job;
-    details_ = new JobEventDetails(detail_type, document, page);
-  }
-
-  virtual void Run() {
-    // Send the notification in the right thread.
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_PRINT_JOB_EVENT,
-        // We know that is is a PrintJob object in this circumstance.
-        content::Source<PrintJob>(static_cast<PrintJob*>(print_job_.get())),
-        content::Details<JobEventDetails>(details_));
-  }
-
-  // The job which originates this notification.
-  scoped_refptr<PrintJobWorkerOwner> print_job_;
-  scoped_refptr<JobEventDetails> details_;
-};
+void NotificationCallback(PrintJobWorkerOwner* print_job,
+                          JobEventDetails::Type detail_type,
+                          PrintedDocument* document,
+                          PrintedPage* page) {
+  JobEventDetails* details = new JobEventDetails(detail_type, document, page);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PRINT_JOB_EVENT,
+      // We know that is is a PrintJob object in this circumstance.
+      content::Source<PrintJob>(static_cast<PrintJob*>(print_job)),
+      content::Details<JobEventDetails>(details));
+}
 
 PrintJobWorker::PrintJobWorker(PrintJobWorkerOwner* owner)
     : Thread("Printing_Worker"),
       owner_(owner),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // The object is created in the IO thread.
   DCHECK_EQ(owner_->message_loop(), MessageLoop::current());
 
   printing_context_.reset(PrintingContext::Create(
       g_browser_process->GetApplicationLocale()));
@@ skipping 192 matching lines @@
     scoped_refptr<PrintedPage> page;
     if (!document_->GetPage(page_number_.ToInt(), &page)) {
       // We need to wait for the page to be available.
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&PrintJobWorker::OnNewPage, weak_factory_.GetWeakPtr()),
           500);
       break;
     }
     // The page is there, print it.
-    SpoolPage(*page);
+    SpoolPage(page);
     ++page_number_;
     if (page_number_ == PageNumber::npos()) {
       OnDocumentDone();
       // Don't touch this anymore since the instance could be destroyed.
       break;
     }
   }
 }
 
 void PrintJobWorker::Cancel() {
   // This is the only function that can be called from any thread.
   printing_context_->Cancel();
   // Cannot touch any member variable since we don't know in which thread
   // context we run.
 }
 
 void PrintJobWorker::OnDocumentDone() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
 
   if (printing_context_->DocumentDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
-  // Tell everyone!
-  NotificationTask* task = new NotificationTask();
-  task->Init(owner_,
-             JobEventDetails::DOC_DONE,
-             document_.get(),
-             NULL);
-  owner_->message_loop()->PostTask(FROM_HERE, task);
+  owner_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
+                            JobEventDetails::DOC_DONE, document_,
+                            scoped_refptr<PrintedPage>()));
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
 }
 
-void PrintJobWorker::SpoolPage(PrintedPage& page) {
+void PrintJobWorker::SpoolPage(PrintedPage* page) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_NE(page_number_, PageNumber::npos());
 
   // Signal everyone that the page is about to be printed.
-  NotificationTask* task = new NotificationTask();
-  task->Init(owner_,
-             JobEventDetails::NEW_PAGE,
-             document_.get(),
-             &page);
-  owner_->message_loop()->PostTask(FROM_HERE, task);
+  owner_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
+                            JobEventDetails::NEW_PAGE, document_,
+                            make_scoped_refptr(page)));
 
   // Preprocess.
   if (printing_context_->NewPage() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Actual printing.
 #if defined(OS_WIN) || defined(OS_MACOSX)
-  document_->RenderPrintedPage(page, printing_context_->context());
+  document_->RenderPrintedPage(*page, printing_context_->context());
 #elif defined(OS_POSIX)
-  document_->RenderPrintedPage(page, printing_context_.get());
+  document_->RenderPrintedPage(*page, printing_context_.get());
 #endif
 
   // Postprocess.
   if (printing_context_->PageDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Signal everyone that the page is printed.
-  task = new NotificationTask();
-  task->Init(owner_,
-             JobEventDetails::PAGE_DONE,
-             document_.get(),
-             &page);
-  owner_->message_loop()->PostTask(FROM_HERE, task);
+  owner_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(NotificationCallback, make_scoped_refptr(owner_),
+                 JobEventDetails::PAGE_DONE, document_,
+                 make_scoped_refptr(page)));
 }
 
 void PrintJobWorker::OnFailure() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
 
   // We may loose our last reference by broadcasting the FAILED event.
   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 
-  NotificationTask* task = new NotificationTask();
-  task->Init(owner_,
-             JobEventDetails::FAILED,
-             document_.get(),
-             NULL);
-  owner_->message_loop()->PostTask(FROM_HERE, task);
+  owner_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
+                            JobEventDetails::FAILED, document_,
+                            scoped_refptr<PrintedPage>()));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing