chrome/browser/printing/print_job.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/printing/print_job.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/threading/thread_restrictions.h"
  11 #include "base/threading/worker_pool.h"
  12 #include "base/timer/timer.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/printing/print_job_worker.h"
  15 #include "content/public/browser/notification_service.h"
  16 #include "printing/printed_document.h"
  17 #include "printing/printed_page.h"
  18
  19 using base::TimeDelta;
  20
  21 namespace {
  22
  23 // Helper function to ensure |owner| is valid until at least |callback| returns.
  24 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
  25                      const base::Closure& callback) {
  26   callback.Run();
  27 }
  28
  29 }  // namespace
  30
  31 namespace printing {
  32
  33 PrintJob::PrintJob()
  34     : ui_message_loop_(base::MessageLoop::current()),
  35       source_(NULL),
  36       worker_(),
  37       settings_(),
  38       is_job_pending_(false),
  39       is_canceling_(false),
  40       is_stopping_(false),
  41       is_stopped_(false),
  42       quit_factory_(this),
  43       weak_ptr_factory_(this) {
  44   DCHECK(ui_message_loop_);
  45   // This is normally a UI message loop, but in unit tests, the message loop is
  46   // of the 'default' type.
  47   DCHECK(base::MessageLoopForUI::IsCurrent() ||
  48          ui_message_loop_->type() == base::MessageLoop::TYPE_DEFAULT);
  49   ui_message_loop_->AddDestructionObserver(this);
  50 }
  51
  52 PrintJob::~PrintJob() {
  53   ui_message_loop_->RemoveDestructionObserver(this);
  54   // The job should be finished (or at least canceled) when it is destroyed.
  55   DCHECK(!is_job_pending_);
  56   DCHECK(!is_canceling_);
  57   if (worker_.get())
  58     DCHECK(worker_->message_loop() == NULL);
  59   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
  60 }
  61
  62 void PrintJob::Initialize(PrintJobWorkerOwner* job,
  63                           PrintedPagesSource* source,
  64                           int page_count) {
  65   DCHECK(!source_);
  66   DCHECK(!worker_.get());
  67   DCHECK(!is_job_pending_);
  68   DCHECK(!is_canceling_);
  69   DCHECK(!document_.get());
  70   source_ = source;
  71   worker_.reset(job->DetachWorker(this));
  72   settings_ = job->settings();
  73
  74   PrintedDocument* new_doc =
  75       new PrintedDocument(settings_, source_, job->cookie());
  76   new_doc->set_page_count(page_count);
  77   UpdatePrintedDocument(new_doc);
  78
  79   // Don't forget to register to our own messages.
  80   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
  81                  content::Source<PrintJob>(this));
  82 }
  83
  84 void PrintJob::Observe(int type,
  85                        const content::NotificationSource& source,
  86                        const content::NotificationDetails& details) {
  87   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
  88   switch (type) {
  89     case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
  90       OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
  91       break;
  92     }
  93     default: {
  94       break;
  95     }
  96   }
  97 }
  98
  99 void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
 100                                PrintingContext::Result result) {
 101   NOTREACHED();
 102 }
 103
 104 PrintJobWorker* PrintJob::DetachWorker(PrintJobWorkerOwner* new_owner) {
 105   NOTREACHED();
 106   return NULL;
 107 }
 108
 109 base::MessageLoop* PrintJob::message_loop() {
 110   return ui_message_loop_;
 111 }
 112
 113 const PrintSettings& PrintJob::settings() const {
 114   return settings_;
 115 }
 116
 117 int PrintJob::cookie() const {
 118   if (!document_.get())
 119     // Always use an invalid cookie in this case.
 120     return 0;
 121   return document_->cookie();
 122 }
 123
 124 void PrintJob::WillDestroyCurrentMessageLoop() {
 125   NOTREACHED();
 126 }
 127
 128 void PrintJob::StartPrinting() {
 129   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
 130   DCHECK(worker_->message_loop());
 131   DCHECK(!is_job_pending_);
 132   if (!worker_->message_loop() || is_job_pending_)
 133     return;
 134
 135   // Real work is done in PrintJobWorker::StartPrinting().
 136   worker_->message_loop()->PostTask(
 137       FROM_HERE,
 138       base::Bind(&HoldRefCallback, make_scoped_refptr(this),
 139                  base::Bind(&PrintJobWorker::StartPrinting,
 140                             base::Unretained(worker_.get()), document_)));
 141   // Set the flag right now.
 142   is_job_pending_ = true;
 143
 144   // Tell everyone!
 145   scoped_refptr<JobEventDetails> details(
 146       new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL));
 147   content::NotificationService::current()->Notify(
 148       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 149       content::Source<PrintJob>(this),
 150       content::Details<JobEventDetails>(details.get()));
 151 }
 152
 153 void PrintJob::Stop() {
 154   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
 155
 156   if (quit_factory_.HasWeakPtrs()) {
 157     // In case we're running a nested message loop to wait for a job to finish,
 158     // and we finished before the timeout, quit the nested loop right away.
 159     Quit();
 160     quit_factory_.InvalidateWeakPtrs();
 161   }
 162
 163   // Be sure to live long enough.
 164   scoped_refptr<PrintJob> handle(this);
 165
 166   base::MessageLoop* worker_loop = worker_->message_loop();
 167   if (worker_loop) {
 168     ControlledWorkerShutdown();
 169
 170     is_job_pending_ = false;
 171     registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
 172                       content::Source<PrintJob>(this));
 173   }
 174   // Flush the cached document.
 175   UpdatePrintedDocument(NULL);
 176 }
 177
 178 void PrintJob::Cancel() {
 179   if (is_canceling_)
 180     return;
 181   is_canceling_ = true;
 182
 183   // Be sure to live long enough.
 184   scoped_refptr<PrintJob> handle(this);
 185
 186   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
 187   base::MessageLoop* worker_loop =
 188       worker_.get() ? worker_->message_loop() : NULL;
 189   if (worker_loop) {
 190     // Call this right now so it renders the context invalid. Do not use
 191     // InvokeLater since it would take too much time.
 192     worker_->Cancel();
 193   }
 194   // Make sure a Cancel() is broadcast.
 195   scoped_refptr<JobEventDetails> details(
 196       new JobEventDetails(JobEventDetails::FAILED, NULL, NULL));
 197   content::NotificationService::current()->Notify(
 198       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 199       content::Source<PrintJob>(this),
 200       content::Details<JobEventDetails>(details.get()));
 201   Stop();
 202   is_canceling_ = false;
 203 }
 204
 205 bool PrintJob::FlushJob(base::TimeDelta timeout) {
 206   // Make sure the object outlive this message loop.
 207   scoped_refptr<PrintJob> handle(this);
 208
 209   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 210       base::Bind(&PrintJob::Quit, quit_factory_.GetWeakPtr()), timeout);
 211
 212   base::MessageLoop::ScopedNestableTaskAllower allow(
 213       base::MessageLoop::current());
 214   base::MessageLoop::current()->Run();
 215
 216   return true;
 217 }
 218
 219 void PrintJob::DisconnectSource() {
 220   source_ = NULL;
 221   if (document_.get())
 222     document_->DisconnectSource();
 223 }
 224
 225 bool PrintJob::is_job_pending() const {
 226   return is_job_pending_;
 227 }
 228
 229 bool PrintJob::is_stopping() const {
 230   return is_stopping_;
 231 }
 232
 233 bool PrintJob::is_stopped() const {
 234   return is_stopped_;
 235 }
 236
 237 PrintedDocument* PrintJob::document() const {
 238   return document_.get();
 239 }
 240
 241 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
 242   if (document_.get() == new_document)
 243     return;
 244
 245   document_ = new_document;
 246
 247   if (document_.get()) {
 248     settings_ = document_->settings();
 249   }
 250
 251   if (worker_.get() && worker_->message_loop()) {
 252     DCHECK(!is_job_pending_);
 253     // Sync the document with the worker.
 254     worker_->message_loop()->PostTask(
 255         FROM_HERE,
 256         base::Bind(&HoldRefCallback, make_scoped_refptr(this),
 257                    base::Bind(&PrintJobWorker::OnDocumentChanged,
 258                               base::Unretained(worker_.get()), document_)));
 259   }
 260 }
 261
 262 void PrintJob::OnNotifyPrintJobEvent(const JobEventDetails& event_details) {
 263   switch (event_details.type()) {
 264     case JobEventDetails::FAILED: {
 265       settings_.Clear();
 266       // No need to cancel since the worker already canceled itself.
 267       Stop();
 268       break;
 269     }
 270     case JobEventDetails::USER_INIT_DONE:
 271     case JobEventDetails::DEFAULT_INIT_DONE:
 272     case JobEventDetails::USER_INIT_CANCELED: {
 273       DCHECK_EQ(event_details.document(), document_.get());
 274       break;
 275     }
 276     case JobEventDetails::NEW_DOC:
 277     case JobEventDetails::NEW_PAGE:
 278     case JobEventDetails::PAGE_DONE:
 279     case JobEventDetails::JOB_DONE:
 280     case JobEventDetails::ALL_PAGES_REQUESTED: {
 281       // Don't care.
 282       break;
 283     }
 284     case JobEventDetails::DOC_DONE: {
 285       // This will call Stop() and broadcast a JOB_DONE message.
 286       base::MessageLoop::current()->PostTask(
 287           FROM_HERE, base::Bind(&PrintJob::OnDocumentDone, this));
 288       break;
 289     }
 290     default: {
 291       NOTREACHED();
 292       break;
 293     }
 294   }
 295 }
 296
 297 void PrintJob::OnDocumentDone() {
 298   // Be sure to live long enough. The instance could be destroyed by the
 299   // JOB_DONE broadcast.
 300   scoped_refptr<PrintJob> handle(this);
 301
 302   // Stop the worker thread.
 303   Stop();
 304
 305   scoped_refptr<JobEventDetails> details(
 306       new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), NULL));
 307   content::NotificationService::current()->Notify(
 308       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 309       content::Source<PrintJob>(this),
 310       content::Details<JobEventDetails>(details.get()));
 311 }
 312
 313 void PrintJob::ControlledWorkerShutdown() {
 314   DCHECK_EQ(ui_message_loop_, base::MessageLoop::current());
 315
 316   // The deadlock this code works around is specific to window messaging on
 317   // Windows, so we aren't likely to need it on any other platforms.
 318 #if defined(OS_WIN)
 319   // We could easily get into a deadlock case if worker_->Stop() is used; the
 320   // printer driver created a window as a child of the browser window. By
 321   // canceling the job, the printer driver initiated dialog box is destroyed,
 322   // which sends a blocking message to its parent window. If the browser window
 323   // thread is not processing messages, a deadlock occurs.
 324   //
 325   // This function ensures that the dialog box will be destroyed in a timely
 326   // manner by the mere fact that the thread will terminate. So the potential
 327   // deadlock is eliminated.
 328   worker_->StopSoon();
 329
 330   // Run a tight message loop until the worker terminates. It may seems like a
 331   // hack but I see no other way to get it to work flawlessly. The issues here
 332   // are:
 333   // - We don't want to run tasks while the thread is quitting.
 334   // - We want this code path to wait on the thread to quit before continuing.
 335   MSG msg;
 336   HANDLE thread_handle = worker_->thread_handle().platform_handle();
 337   for (; thread_handle;) {
 338     // Note that we don't do any kind of message prioritization since we don't
 339     // execute any pending task or timer.
 340     DWORD result = MsgWaitForMultipleObjects(1, &thread_handle,
 341                                              FALSE, INFINITE, QS_ALLINPUT);
 342     if (result == WAIT_OBJECT_0 + 1) {
 343       while (PeekMessage(&msg, NULL, 0, 0, TRUE) > 0) {
 344         TranslateMessage(&msg);
 345         DispatchMessage(&msg);
 346       }
 347       // Continue looping.
 348     } else if (result == WAIT_OBJECT_0) {
 349       // The thread quit.
 350       break;
 351     } else {
 352       // An error occurred. Assume the thread quit.
 353       NOTREACHED();
 354       break;
 355     }
 356   }
 357 #endif
 358
 359
 360   // Now make sure the thread object is cleaned up. Do this on a worker
 361   // thread because it may block.
 362   is_stopping_ = true;
 363
 364   base::WorkerPool::PostTaskAndReply(
 365       FROM_HERE,
 366       base::Bind(&PrintJobWorker::Stop,
 367                  base::Unretained(worker_.get())),
 368       base::Bind(&PrintJob::HoldUntilStopIsCalled,
 369                  weak_ptr_factory_.GetWeakPtr(),
 370                  scoped_refptr<PrintJob>(this)),
 371       false);
 372 }
 373
 374 void PrintJob::HoldUntilStopIsCalled(const scoped_refptr<PrintJob>&) {
 375   is_stopped_ = true;
 376   is_stopping_ = false;
 377 }
 378
 379 void PrintJob::Quit() {
 380   base::MessageLoop::current()->Quit();
 381 }
 382
 383 // Takes settings_ ownership and will be deleted in the receiving thread.
 384 JobEventDetails::JobEventDetails(Type type,
 385                                  PrintedDocument* document,
 386                                  PrintedPage* page)
 387     : document_(document),
 388       page_(page),
 389       type_(type) {
 390 }
 391
 392 JobEventDetails::~JobEventDetails() {
 393 }
 394
 395 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 396
 397 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 398
 399 }  // namespace printing