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/browser_thread.h"
  16 #include "content/public/browser/notification_service.h"
  17 #include "printing/printed_document.h"
  18 #include "printing/printed_page.h"
  19
  20 #if defined(OS_WIN)
  21 #include "chrome/browser/printing/pdf_to_emf_converter.h"
  22 #include "printing/pdf_render_settings.h"
  23 #endif
  24
  25 using base::TimeDelta;
  26
  27 namespace {
  28
  29 // Helper function to ensure |owner| is valid until at least |callback| returns.
  30 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
  31                      const base::Closure& callback) {
  32   callback.Run();
  33 }
  34
  35 }  // namespace
  36
  37 namespace printing {
  38
  39 PrintJob::PrintJob()
  40     : source_(NULL),
  41       worker_(),
  42       settings_(),
  43       is_job_pending_(false),
  44       is_canceling_(false),
  45       quit_factory_(this) {
  46   // This is normally a UI message loop, but in unit tests, the message loop is
  47   // of the 'default' type.
  48   DCHECK(base::MessageLoopForUI::IsCurrent() ||
  49          base::MessageLoop::current()->type() ==
  50              base::MessageLoop::TYPE_DEFAULT);
  51 }
  52
  53 PrintJob::~PrintJob() {
  54   // The job should be finished (or at least canceled) when it is destroyed.
  55   DCHECK(!is_job_pending_);
  56   DCHECK(!is_canceling_);
  57   DCHECK(!worker_ || !worker_->IsRunning());
  58   DCHECK(RunsTasksOnCurrentThread());
  59 }
  60
  61 void PrintJob::Initialize(PrintJobWorkerOwner* job,
  62                           PrintedPagesSource* source,
  63                           int page_count) {
  64   DCHECK(!source_);
  65   DCHECK(!worker_.get());
  66   DCHECK(!is_job_pending_);
  67   DCHECK(!is_canceling_);
  68   DCHECK(!document_.get());
  69   source_ = source;
  70   worker_.reset(job->DetachWorker(this));
  71   settings_ = job->settings();
  72
  73   PrintedDocument* new_doc =
  74       new PrintedDocument(settings_,
  75                           source_,
  76                           job->cookie(),
  77                           content::BrowserThread::GetBlockingPool());
  78   new_doc->set_page_count(page_count);
  79   UpdatePrintedDocument(new_doc);
  80
  81   // Don't forget to register to our own messages.
  82   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
  83                  content::Source<PrintJob>(this));
  84 }
  85
  86 void PrintJob::Observe(int type,
  87                        const content::NotificationSource& source,
  88                        const content::NotificationDetails& details) {
  89   DCHECK(RunsTasksOnCurrentThread());
  90   switch (type) {
  91     case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
  92       OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
  93       break;
  94     }
  95     default: {
  96       break;
  97     }
  98   }
  99 }
 100
 101 void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
 102                                PrintingContext::Result result) {
 103   NOTREACHED();
 104 }
 105
 106 PrintJobWorker* PrintJob::DetachWorker(PrintJobWorkerOwner* new_owner) {
 107   NOTREACHED();
 108   return NULL;
 109 }
 110
 111 const PrintSettings& PrintJob::settings() const {
 112   return settings_;
 113 }
 114
 115 int PrintJob::cookie() const {
 116   if (!document_.get())
 117     // Always use an invalid cookie in this case.
 118     return 0;
 119   return document_->cookie();
 120 }
 121
 122 void PrintJob::StartPrinting() {
 123   DCHECK(RunsTasksOnCurrentThread());
 124   DCHECK(worker_->IsRunning());
 125   DCHECK(!is_job_pending_);
 126   if (!worker_->IsRunning() || is_job_pending_)
 127     return;
 128
 129   // Real work is done in PrintJobWorker::StartPrinting().
 130   worker_->PostTask(FROM_HERE,
 131                     base::Bind(&HoldRefCallback,
 132                                make_scoped_refptr(this),
 133                                base::Bind(&PrintJobWorker::StartPrinting,
 134                                           base::Unretained(worker_.get()),
 135                                           document_)));
 136   // Set the flag right now.
 137   is_job_pending_ = true;
 138
 139   // Tell everyone!
 140   scoped_refptr<JobEventDetails> details(
 141       new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL));
 142   content::NotificationService::current()->Notify(
 143       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 144       content::Source<PrintJob>(this),
 145       content::Details<JobEventDetails>(details.get()));
 146 }
 147
 148 void PrintJob::Stop() {
 149   DCHECK(RunsTasksOnCurrentThread());
 150
 151   if (quit_factory_.HasWeakPtrs()) {
 152     // In case we're running a nested message loop to wait for a job to finish,
 153     // and we finished before the timeout, quit the nested loop right away.
 154     Quit();
 155     quit_factory_.InvalidateWeakPtrs();
 156   }
 157
 158   // Be sure to live long enough.
 159   scoped_refptr<PrintJob> handle(this);
 160
 161   if (worker_->IsRunning()) {
 162     ControlledWorkerShutdown();
 163   } else {
 164     // Flush the cached document.
 165     UpdatePrintedDocument(NULL);
 166   }
 167 }
 168
 169 void PrintJob::Cancel() {
 170   if (is_canceling_)
 171     return;
 172   is_canceling_ = true;
 173
 174   // Be sure to live long enough.
 175   scoped_refptr<PrintJob> handle(this);
 176
 177   DCHECK(RunsTasksOnCurrentThread());
 178   if (worker_ && worker_->IsRunning()) {
 179     // Call this right now so it renders the context invalid. Do not use
 180     // InvokeLater since it would take too much time.
 181     worker_->Cancel();
 182   }
 183   // Make sure a Cancel() is broadcast.
 184   scoped_refptr<JobEventDetails> details(
 185       new JobEventDetails(JobEventDetails::FAILED, NULL, NULL));
 186   content::NotificationService::current()->Notify(
 187       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 188       content::Source<PrintJob>(this),
 189       content::Details<JobEventDetails>(details.get()));
 190   Stop();
 191   is_canceling_ = false;
 192 }
 193
 194 bool PrintJob::FlushJob(base::TimeDelta timeout) {
 195   // Make sure the object outlive this message loop.
 196   scoped_refptr<PrintJob> handle(this);
 197
 198   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 199       base::Bind(&PrintJob::Quit, quit_factory_.GetWeakPtr()), timeout);
 200
 201   base::MessageLoop::ScopedNestableTaskAllower allow(
 202       base::MessageLoop::current());
 203   base::MessageLoop::current()->Run();
 204
 205   return true;
 206 }
 207
 208 void PrintJob::DisconnectSource() {
 209   source_ = NULL;
 210   if (document_.get())
 211     document_->DisconnectSource();
 212 }
 213
 214 bool PrintJob::is_job_pending() const {
 215   return is_job_pending_;
 216 }
 217
 218 PrintedDocument* PrintJob::document() const {
 219   return document_.get();
 220 }
 221
 222 #if defined(OS_WIN)
 223
 224 class PrintJob::PdfToEmfState {
 225  public:
 226   PdfToEmfState(const gfx::Size& page_size, const gfx::Rect& content_area)
 227       : page_count_(0),
 228         current_page_(0),
 229         pages_in_progress_(0),
 230         page_size_(page_size),
 231         content_area_(content_area),
 232         converter_(PdfToEmfConverter::CreateDefault()) {}
 233
 234   void Start(const scoped_refptr<base::RefCountedMemory>& data,
 235              const PdfRenderSettings& conversion_settings,
 236              const PdfToEmfConverter::StartCallback& start_callback) {
 237     converter_->Start(data, conversion_settings, start_callback);
 238   }
 239
 240   void GetMorePages(
 241       const PdfToEmfConverter::GetPageCallback& get_page_callback) {
 242     const int kMaxNumberOfTempFilesPerDocument = 3;
 243     while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
 244            current_page_ < page_count_) {
 245       ++pages_in_progress_;
 246       converter_->GetPage(current_page_++, get_page_callback);
 247     }
 248   }
 249
 250   void OnPageProcessed(
 251       const PdfToEmfConverter::GetPageCallback& get_page_callback) {
 252     --pages_in_progress_;
 253     GetMorePages(get_page_callback);
 254     // Release converter if we don't need this any more.
 255     if (!pages_in_progress_ && current_page_ >= page_count_)
 256       converter_.reset();
 257   }
 258
 259   void set_page_count(int page_count) { page_count_ = page_count; }
 260   gfx::Size page_size() const { return page_size_; }
 261   gfx::Rect content_area() const { return content_area_; }
 262
 263  private:
 264   int page_count_;
 265   int current_page_;
 266   int pages_in_progress_;
 267   gfx::Size page_size_;
 268   gfx::Rect content_area_;
 269   scoped_ptr<PdfToEmfConverter> converter_;
 270 };
 271
 272 void PrintJob::StartPdfToEmfConversion(
 273     const scoped_refptr<base::RefCountedMemory>& bytes,
 274     const gfx::Size& page_size,
 275     const gfx::Rect& content_area) {
 276   DCHECK(!ptd_to_emf_state_.get());
 277   ptd_to_emf_state_.reset(new PdfToEmfState(page_size, content_area));
 278   const int kPrinterDpi = settings().dpi();
 279   ptd_to_emf_state_->Start(
 280       bytes,
 281       printing::PdfRenderSettings(content_area, kPrinterDpi, true),
 282       base::Bind(&PrintJob::OnPdfToEmfStarted, this));
 283 }
 284
 285 void PrintJob::OnPdfToEmfStarted(int page_count) {
 286   if (page_count <= 0) {
 287     ptd_to_emf_state_.reset();
 288     Cancel();
 289     return;
 290   }
 291   ptd_to_emf_state_->set_page_count(page_count);
 292   ptd_to_emf_state_->GetMorePages(
 293       base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 294 }
 295
 296 void PrintJob::OnPdfToEmfPageConverted(int page_number,
 297                                        float scale_factor,
 298                                        scoped_ptr<MetafilePlayer> emf) {
 299   DCHECK(ptd_to_emf_state_);
 300   if (!document_.get() || !emf) {
 301     ptd_to_emf_state_.reset();
 302     Cancel();
 303     return;
 304   }
 305
 306   // Update the rendered document. It will send notifications to the listener.
 307   document_->SetPage(page_number,
 308                      emf.Pass(),
 309                      scale_factor,
 310                      ptd_to_emf_state_->page_size(),
 311                      ptd_to_emf_state_->content_area());
 312
 313   ptd_to_emf_state_->GetMorePages(
 314       base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 315 }
 316
 317 #endif  // OS_WIN
 318
 319 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
 320   if (document_.get() == new_document)
 321     return;
 322
 323   document_ = new_document;
 324
 325   if (document_.get()) {
 326     settings_ = document_->settings();
 327   }
 328
 329   if (worker_) {
 330     DCHECK(!is_job_pending_);
 331     // Sync the document with the worker.
 332     worker_->PostTask(FROM_HERE,
 333                       base::Bind(&HoldRefCallback,
 334                                  make_scoped_refptr(this),
 335                                  base::Bind(&PrintJobWorker::OnDocumentChanged,
 336                                             base::Unretained(worker_.get()),
 337                                             document_)));
 338   }
 339 }
 340
 341 void PrintJob::OnNotifyPrintJobEvent(const JobEventDetails& event_details) {
 342   switch (event_details.type()) {
 343     case JobEventDetails::FAILED: {
 344       settings_.Clear();
 345       // No need to cancel since the worker already canceled itself.
 346       Stop();
 347       break;
 348     }
 349     case JobEventDetails::USER_INIT_DONE:
 350     case JobEventDetails::DEFAULT_INIT_DONE:
 351     case JobEventDetails::USER_INIT_CANCELED: {
 352       DCHECK_EQ(event_details.document(), document_.get());
 353       break;
 354     }
 355     case JobEventDetails::NEW_DOC:
 356     case JobEventDetails::NEW_PAGE:
 357     case JobEventDetails::JOB_DONE:
 358     case JobEventDetails::ALL_PAGES_REQUESTED: {
 359       // Don't care.
 360       break;
 361     }
 362     case JobEventDetails::DOC_DONE: {
 363       // This will call Stop() and broadcast a JOB_DONE message.
 364       base::MessageLoop::current()->PostTask(
 365           FROM_HERE, base::Bind(&PrintJob::OnDocumentDone, this));
 366       break;
 367     }
 368     case JobEventDetails::PAGE_DONE:
 369 #if defined(OS_WIN)
 370       ptd_to_emf_state_->OnPageProcessed(
 371           base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 372 #endif  // OS_WIN
 373       break;
 374     default: {
 375       NOTREACHED();
 376       break;
 377     }
 378   }
 379 }
 380
 381 void PrintJob::OnDocumentDone() {
 382   // Be sure to live long enough. The instance could be destroyed by the
 383   // JOB_DONE broadcast.
 384   scoped_refptr<PrintJob> handle(this);
 385
 386   // Stop the worker thread.
 387   Stop();
 388
 389   scoped_refptr<JobEventDetails> details(
 390       new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), NULL));
 391   content::NotificationService::current()->Notify(
 392       chrome::NOTIFICATION_PRINT_JOB_EVENT,
 393       content::Source<PrintJob>(this),
 394       content::Details<JobEventDetails>(details.get()));
 395 }
 396
 397 void PrintJob::ControlledWorkerShutdown() {
 398   DCHECK(RunsTasksOnCurrentThread());
 399
 400   // The deadlock this code works around is specific to window messaging on
 401   // Windows, so we aren't likely to need it on any other platforms.
 402 #if defined(OS_WIN)
 403   // We could easily get into a deadlock case if worker_->Stop() is used; the
 404   // printer driver created a window as a child of the browser window. By
 405   // canceling the job, the printer driver initiated dialog box is destroyed,
 406   // which sends a blocking message to its parent window. If the browser window
 407   // thread is not processing messages, a deadlock occurs.
 408   //
 409   // This function ensures that the dialog box will be destroyed in a timely
 410   // manner by the mere fact that the thread will terminate. So the potential
 411   // deadlock is eliminated.
 412   worker_->StopSoon();
 413
 414   // Delay shutdown until the worker terminates.  We want this code path
 415   // to wait on the thread to quit before continuing.
 416   if (worker_->IsRunning()) {
 417     base::MessageLoop::current()->PostDelayedTask(
 418         FROM_HERE,
 419         base::Bind(&PrintJob::ControlledWorkerShutdown, this),
 420         base::TimeDelta::FromMilliseconds(100));
 421     return;
 422   }
 423 #endif
 424
 425
 426   // Now make sure the thread object is cleaned up. Do this on a worker
 427   // thread because it may block.
 428   base::WorkerPool::PostTaskAndReply(
 429       FROM_HERE,
 430       base::Bind(&PrintJobWorker::Stop, base::Unretained(worker_.get())),
 431       base::Bind(&PrintJob::HoldUntilStopIsCalled, this),
 432       false);
 433
 434   is_job_pending_ = false;
 435   registrar_.RemoveAll();
 436   UpdatePrintedDocument(NULL);
 437 }
 438
 439 void PrintJob::HoldUntilStopIsCalled() {
 440 }
 441
 442 void PrintJob::Quit() {
 443   base::MessageLoop::current()->Quit();
 444 }
 445
 446 // Takes settings_ ownership and will be deleted in the receiving thread.
 447 JobEventDetails::JobEventDetails(Type type,
 448                                  PrintedDocument* document,
 449                                  PrintedPage* page)
 450     : document_(document),
 451       page_(page),
 452       type_(type) {
 453 }
 454
 455 JobEventDetails::~JobEventDetails() {
 456 }
 457
 458 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 459
 460 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 461
 462 }  // namespace printing