chrome/browser/printing/print_view_manager_base.cc

   1 // Copyright 2013 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_view_manager_base.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/timer/timer.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/printing/print_job.h"
  15 #include "chrome/browser/printing/print_job_manager.h"
  16 #include "chrome/browser/printing/printer_query.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/ui/simple_message_box.h"
  19 #include "chrome/common/pref_names.h"
  20 #include "chrome/grit/generated_resources.h"
  21 #include "components/printing/common/print_messages.h"
  22 #include "content/public/browser/browser_thread.h"
  23 #include "content/public/browser/notification_details.h"
  24 #include "content/public/browser/notification_service.h"
  25 #include "content/public/browser/notification_source.h"
  26 #include "content/public/browser/render_view_host.h"
  27 #include "content/public/browser/web_contents.h"
  28 #include "printing/pdf_metafile_skia.h"
  29 #include "printing/printed_document.h"
  30 #include "ui/base/l10n/l10n_util.h"
  31
  32 #if defined(ENABLE_PRINT_PREVIEW)
  33 #include "chrome/browser/printing/print_error_dialog.h"
  34 #endif
  35
  36 using base::TimeDelta;
  37 using content::BrowserThread;
  38
  39 namespace printing {
  40
  41 namespace {
  42
  43 }  // namespace
  44
  45 PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
  46     : content::WebContentsObserver(web_contents),
  47       number_pages_(0),
  48       printing_succeeded_(false),
  49       inside_inner_message_loop_(false),
  50       cookie_(0),
  51       queue_(g_browser_process->print_job_manager()->queue()) {
  52   DCHECK(queue_.get());
  53 #if !defined(OS_MACOSX)
  54   expecting_first_page_ = true;
  55 #endif  // OS_MACOSX
  56   Profile* profile =
  57       Profile::FromBrowserContext(web_contents->GetBrowserContext());
  58   printing_enabled_.Init(
  59       prefs::kPrintingEnabled,
  60       profile->GetPrefs(),
  61       base::Bind(&PrintViewManagerBase::UpdateScriptedPrintingBlocked,
  62                  base::Unretained(this)));
  63 }
  64
  65 PrintViewManagerBase::~PrintViewManagerBase() {
  66   ReleasePrinterQuery();
  67   DisconnectFromCurrentPrintJob();
  68 }
  69
  70 #if defined(ENABLE_BASIC_PRINTING)
  71 bool PrintViewManagerBase::PrintNow() {
  72   return PrintNowInternal(new PrintMsg_PrintPages(routing_id()));
  73 }
  74 #endif  // ENABLE_BASIC_PRINTING
  75
  76 void PrintViewManagerBase::UpdateScriptedPrintingBlocked() {
  77   Send(new PrintMsg_SetScriptedPrintingBlocked(
  78        routing_id(),
  79        !printing_enabled_.GetValue()));
  80 }
  81
  82 void PrintViewManagerBase::NavigationStopped() {
  83   // Cancel the current job, wait for the worker to finish.
  84   TerminatePrintJob(true);
  85 }
  86
  87 void PrintViewManagerBase::RenderProcessGone(base::TerminationStatus status) {
  88   ReleasePrinterQuery();
  89
  90   if (!print_job_.get())
  91     return;
  92
  93   scoped_refptr<PrintedDocument> document(print_job_->document());
  94   if (document.get()) {
  95     // If IsComplete() returns false, the document isn't completely rendered.
  96     // Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
  97     // the print job may finish without problem.
  98     TerminatePrintJob(!document->IsComplete());
  99   }
 100 }
 101
 102 base::string16 PrintViewManagerBase::RenderSourceName() {
 103   base::string16 name(web_contents()->GetTitle());
 104   if (name.empty())
 105     name = l10n_util::GetStringUTF16(IDS_DEFAULT_PRINT_DOCUMENT_TITLE);
 106   return name;
 107 }
 108
 109 void PrintViewManagerBase::OnDidGetPrintedPagesCount(int cookie,
 110                                                      int number_pages) {
 111   DCHECK_GT(cookie, 0);
 112   DCHECK_GT(number_pages, 0);
 113   number_pages_ = number_pages;
 114   OpportunisticallyCreatePrintJob(cookie);
 115 }
 116
 117 void PrintViewManagerBase::OnDidGetDocumentCookie(int cookie) {
 118   cookie_ = cookie;
 119 }
 120
 121 void PrintViewManagerBase::OnDidPrintPage(
 122   const PrintHostMsg_DidPrintPage_Params& params) {
 123   if (!OpportunisticallyCreatePrintJob(params.document_cookie))
 124     return;
 125
 126   PrintedDocument* document = print_job_->document();
 127   if (!document || params.document_cookie != document->cookie()) {
 128     // Out of sync. It may happen since we are completely asynchronous. Old
 129     // spurious messages can be received if one of the processes is overloaded.
 130     return;
 131   }
 132
 133 #if defined(OS_MACOSX)
 134   const bool metafile_must_be_valid = true;
 135 #else
 136   const bool metafile_must_be_valid = expecting_first_page_;
 137   expecting_first_page_ = false;
 138 #endif  // OS_MACOSX
 139
 140   base::SharedMemory shared_buf(params.metafile_data_handle, true);
 141   if (metafile_must_be_valid) {
 142     if (!shared_buf.Map(params.data_size)) {
 143       NOTREACHED() << "couldn't map";
 144       web_contents()->Stop();
 145       return;
 146     }
 147   }
 148
 149   scoped_ptr<PdfMetafileSkia> metafile(new PdfMetafileSkia);
 150   if (metafile_must_be_valid) {
 151     if (!metafile->InitFromData(shared_buf.memory(), params.data_size)) {
 152       NOTREACHED() << "Invalid metafile header";
 153       web_contents()->Stop();
 154       return;
 155     }
 156   }
 157
 158 #if !defined(OS_WIN)
 159   // Update the rendered document. It will send notifications to the listener.
 160   document->SetPage(params.page_number,
 161                     metafile.Pass(),
 162                     params.page_size,
 163                     params.content_area);
 164
 165   ShouldQuitFromInnerMessageLoop();
 166 #else
 167   if (metafile_must_be_valid) {
 168     scoped_refptr<base::RefCountedBytes> bytes = new base::RefCountedBytes(
 169         reinterpret_cast<const unsigned char*>(shared_buf.memory()),
 170         params.data_size);
 171
 172     document->DebugDumpData(bytes.get(), FILE_PATH_LITERAL(".pdf"));
 173     print_job_->StartPdfToEmfConversion(
 174         bytes, params.page_size, params.content_area);
 175   }
 176 #endif  // !OS_WIN
 177 }
 178
 179 void PrintViewManagerBase::OnPrintingFailed(int cookie) {
 180   if (cookie != cookie_) {
 181     NOTREACHED();
 182     return;
 183   }
 184
 185 #if defined(ENABLE_PRINT_PREVIEW)
 186   chrome::ShowPrintErrorDialog();
 187 #endif
 188
 189   ReleasePrinterQuery();
 190
 191   content::NotificationService::current()->Notify(
 192       chrome::NOTIFICATION_PRINT_JOB_RELEASED,
 193       content::Source<content::WebContents>(web_contents()),
 194       content::NotificationService::NoDetails());
 195 }
 196
 197 void PrintViewManagerBase::OnShowInvalidPrinterSettingsError() {
 198   chrome::ShowMessageBox(NULL,
 199                          base::string16(),
 200                          l10n_util::GetStringUTF16(
 201                              IDS_PRINT_INVALID_PRINTER_SETTINGS),
 202                          chrome::MESSAGE_BOX_TYPE_WARNING);
 203 }
 204
 205 void PrintViewManagerBase::DidStartLoading() {
 206   UpdateScriptedPrintingBlocked();
 207 }
 208
 209 bool PrintViewManagerBase::OnMessageReceived(const IPC::Message& message) {
 210   bool handled = true;
 211   IPC_BEGIN_MESSAGE_MAP(PrintViewManagerBase, message)
 212     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPrintedPagesCount,
 213                         OnDidGetPrintedPagesCount)
 214     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetDocumentCookie,
 215                         OnDidGetDocumentCookie)
 216     IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
 217     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintingFailed, OnPrintingFailed)
 218     IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError,
 219                         OnShowInvalidPrinterSettingsError);
 220     IPC_MESSAGE_UNHANDLED(handled = false)
 221   IPC_END_MESSAGE_MAP()
 222   return handled;
 223 }
 224
 225 void PrintViewManagerBase::Observe(
 226     int type,
 227     const content::NotificationSource& source,
 228     const content::NotificationDetails& details) {
 229   switch (type) {
 230     case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
 231       OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
 232       break;
 233     }
 234     default: {
 235       NOTREACHED();
 236       break;
 237     }
 238   }
 239 }
 240
 241 void PrintViewManagerBase::OnNotifyPrintJobEvent(
 242     const JobEventDetails& event_details) {
 243   switch (event_details.type()) {
 244     case JobEventDetails::FAILED: {
 245       TerminatePrintJob(true);
 246
 247       content::NotificationService::current()->Notify(
 248           chrome::NOTIFICATION_PRINT_JOB_RELEASED,
 249           content::Source<content::WebContents>(web_contents()),
 250           content::NotificationService::NoDetails());
 251       break;
 252     }
 253     case JobEventDetails::USER_INIT_DONE:
 254     case JobEventDetails::DEFAULT_INIT_DONE:
 255     case JobEventDetails::USER_INIT_CANCELED: {
 256       NOTREACHED();
 257       break;
 258     }
 259     case JobEventDetails::ALL_PAGES_REQUESTED: {
 260       ShouldQuitFromInnerMessageLoop();
 261       break;
 262     }
 263     case JobEventDetails::NEW_DOC:
 264     case JobEventDetails::NEW_PAGE:
 265     case JobEventDetails::PAGE_DONE:
 266     case JobEventDetails::DOC_DONE: {
 267       // Don't care about the actual printing process.
 268       break;
 269     }
 270     case JobEventDetails::JOB_DONE: {
 271       // Printing is done, we don't need it anymore.
 272       // print_job_->is_job_pending() may still be true, depending on the order
 273       // of object registration.
 274       printing_succeeded_ = true;
 275       ReleasePrintJob();
 276
 277       content::NotificationService::current()->Notify(
 278           chrome::NOTIFICATION_PRINT_JOB_RELEASED,
 279           content::Source<content::WebContents>(web_contents()),
 280           content::NotificationService::NoDetails());
 281       break;
 282     }
 283     default: {
 284       NOTREACHED();
 285       break;
 286     }
 287   }
 288 }
 289
 290 bool PrintViewManagerBase::RenderAllMissingPagesNow() {
 291   if (!print_job_.get() || !print_job_->is_job_pending())
 292     return false;
 293
 294   // We can't print if there is no renderer.
 295   if (!web_contents() ||
 296       !web_contents()->GetRenderViewHost() ||
 297       !web_contents()->GetRenderViewHost()->IsRenderViewLive()) {
 298     return false;
 299   }
 300
 301   // Is the document already complete?
 302   if (print_job_->document() && print_job_->document()->IsComplete()) {
 303     printing_succeeded_ = true;
 304     return true;
 305   }
 306
 307   // WebContents is either dying or a second consecutive request to print
 308   // happened before the first had time to finish. We need to render all the
 309   // pages in an hurry if a print_job_ is still pending. No need to wait for it
 310   // to actually spool the pages, only to have the renderer generate them. Run
 311   // a message loop until we get our signal that the print job is satisfied.
 312   // PrintJob will send a ALL_PAGES_REQUESTED after having received all the
 313   // pages it needs. MessageLoop::current()->Quit() will be called as soon as
 314   // print_job_->document()->IsComplete() is true on either ALL_PAGES_REQUESTED
 315   // or in DidPrintPage(). The check is done in
 316   // ShouldQuitFromInnerMessageLoop().
 317   // BLOCKS until all the pages are received. (Need to enable recursive task)
 318   if (!RunInnerMessageLoop()) {
 319     // This function is always called from DisconnectFromCurrentPrintJob() so we
 320     // know that the job will be stopped/canceled in any case.
 321     return false;
 322   }
 323   return true;
 324 }
 325
 326 void PrintViewManagerBase::ShouldQuitFromInnerMessageLoop() {
 327   // Look at the reason.
 328   DCHECK(print_job_->document());
 329   if (print_job_->document() &&
 330       print_job_->document()->IsComplete() &&
 331       inside_inner_message_loop_) {
 332     // We are in a message loop created by RenderAllMissingPagesNow. Quit from
 333     // it.
 334     base::MessageLoop::current()->Quit();
 335     inside_inner_message_loop_ = false;
 336   }
 337 }
 338
 339 bool PrintViewManagerBase::CreateNewPrintJob(PrintJobWorkerOwner* job) {
 340   DCHECK(!inside_inner_message_loop_);
 341
 342   // Disconnect the current print_job_.
 343   DisconnectFromCurrentPrintJob();
 344
 345   // We can't print if there is no renderer.
 346   if (!web_contents()->GetRenderViewHost() ||
 347       !web_contents()->GetRenderViewHost()->IsRenderViewLive()) {
 348     return false;
 349   }
 350
 351   // Ask the renderer to generate the print preview, create the print preview
 352   // view and switch to it, initialize the printer and show the print dialog.
 353   DCHECK(!print_job_.get());
 354   DCHECK(job);
 355   if (!job)
 356     return false;
 357
 358   print_job_ = new PrintJob();
 359   print_job_->Initialize(job, this, number_pages_);
 360   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
 361                  content::Source<PrintJob>(print_job_.get()));
 362   printing_succeeded_ = false;
 363   return true;
 364 }
 365
 366 void PrintViewManagerBase::DisconnectFromCurrentPrintJob() {
 367   // Make sure all the necessary rendered page are done. Don't bother with the
 368   // return value.
 369   bool result = RenderAllMissingPagesNow();
 370
 371   // Verify that assertion.
 372   if (print_job_.get() &&
 373       print_job_->document() &&
 374       !print_job_->document()->IsComplete()) {
 375     DCHECK(!result);
 376     // That failed.
 377     TerminatePrintJob(true);
 378   } else {
 379     // DO NOT wait for the job to finish.
 380     ReleasePrintJob();
 381   }
 382 #if !defined(OS_MACOSX)
 383   expecting_first_page_ = true;
 384 #endif  // OS_MACOSX
 385 }
 386
 387 void PrintViewManagerBase::PrintingDone(bool success) {
 388   if (!print_job_.get())
 389     return;
 390   Send(new PrintMsg_PrintingDone(routing_id(), success));
 391 }
 392
 393 void PrintViewManagerBase::TerminatePrintJob(bool cancel) {
 394   if (!print_job_.get())
 395     return;
 396
 397   if (cancel) {
 398     // We don't need the metafile data anymore because the printing is canceled.
 399     print_job_->Cancel();
 400     inside_inner_message_loop_ = false;
 401   } else {
 402     DCHECK(!inside_inner_message_loop_);
 403     DCHECK(!print_job_->document() || print_job_->document()->IsComplete());
 404
 405     // WebContents is either dying or navigating elsewhere. We need to render
 406     // all the pages in an hurry if a print job is still pending. This does the
 407     // trick since it runs a blocking message loop:
 408     print_job_->Stop();
 409   }
 410   ReleasePrintJob();
 411 }
 412
 413 void PrintViewManagerBase::ReleasePrintJob() {
 414   if (!print_job_.get())
 415     return;
 416
 417   PrintingDone(printing_succeeded_);
 418
 419   registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
 420                     content::Source<PrintJob>(print_job_.get()));
 421   print_job_->DisconnectSource();
 422   // Don't close the worker thread.
 423   print_job_ = NULL;
 424 }
 425
 426 bool PrintViewManagerBase::RunInnerMessageLoop() {
 427   // This value may actually be too low:
 428   //
 429   // - If we're looping because of printer settings initialization, the premise
 430   // here is that some poor users have their print server away on a VPN over a
 431   // slow connection. In this situation, the simple fact of opening the printer
 432   // can be dead slow. On the other side, we don't want to die infinitely for a
 433   // real network error. Give the printer 60 seconds to comply.
 434   //
 435   // - If we're looping because of renderer page generation, the renderer could
 436   // be CPU bound, the page overly complex/large or the system just
 437   // memory-bound.
 438   static const int kPrinterSettingsTimeout = 60000;
 439   base::OneShotTimer<base::MessageLoop> quit_timer;
 440   quit_timer.Start(FROM_HERE,
 441                    TimeDelta::FromMilliseconds(kPrinterSettingsTimeout),
 442                    base::MessageLoop::current(), &base::MessageLoop::Quit);
 443
 444   inside_inner_message_loop_ = true;
 445
 446   // Need to enable recursive task.
 447   {
 448     base::MessageLoop::ScopedNestableTaskAllower allow(
 449         base::MessageLoop::current());
 450     base::MessageLoop::current()->Run();
 451   }
 452
 453   bool success = true;
 454   if (inside_inner_message_loop_) {
 455     // Ok we timed out. That's sad.
 456     inside_inner_message_loop_ = false;
 457     success = false;
 458   }
 459
 460   return success;
 461 }
 462
 463 bool PrintViewManagerBase::OpportunisticallyCreatePrintJob(int cookie) {
 464   if (print_job_.get())
 465     return true;
 466
 467   if (!cookie) {
 468     // Out of sync. It may happens since we are completely asynchronous. Old
 469     // spurious message can happen if one of the processes is overloaded.
 470     return false;
 471   }
 472
 473   // The job was initiated by a script. Time to get the corresponding worker
 474   // thread.
 475   scoped_refptr<PrinterQuery> queued_query = queue_->PopPrinterQuery(cookie);
 476   if (!queued_query.get()) {
 477     NOTREACHED();
 478     return false;
 479   }
 480
 481   if (!CreateNewPrintJob(queued_query.get())) {
 482     // Don't kill anything.
 483     return false;
 484   }
 485
 486   // Settings are already loaded. Go ahead. This will set
 487   // print_job_->is_job_pending() to true.
 488   print_job_->StartPrinting();
 489   return true;
 490 }
 491
 492 bool PrintViewManagerBase::PrintNowInternal(IPC::Message* message) {
 493   // Don't print / print preview interstitials.
 494   if (web_contents()->ShowingInterstitialPage()) {
 495     delete message;
 496     return false;
 497   }
 498   return Send(message);
 499 }
 500
 501 void PrintViewManagerBase::ReleasePrinterQuery() {
 502   if (!cookie_)
 503     return;
 504
 505   int cookie = cookie_;
 506   cookie_ = 0;
 507
 508   printing::PrintJobManager* print_job_manager =
 509       g_browser_process->print_job_manager();
 510   // May be NULL in tests.
 511   if (!print_job_manager)
 512     return;
 513
 514   scoped_refptr<printing::PrinterQuery> printer_query;
 515   printer_query = queue_->PopPrinterQuery(cookie);
 516   if (!printer_query.get())
 517     return;
 518   BrowserThread::PostTask(
 519       BrowserThread::IO, FROM_HERE,
 520       base::Bind(&PrinterQuery::StopWorker, printer_query.get()));
 521 }
 522
 523 }  // namespace printing