chrome/browser/printing/print_job_worker.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_worker.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/location.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/thread_task_runner_handle.h"
  15 #include "base/values.h"
  16 #include "chrome/browser/browser_process.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "chrome/browser/printing/print_job.h"
  19 #include "chrome/grit/generated_resources.h"
  20 #include "content/public/browser/browser_thread.h"
  21 #include "content/public/browser/notification_service.h"
  22 #include "content/public/browser/render_view_host.h"
  23 #include "content/public/browser/web_contents.h"
  24 #include "printing/print_job_constants.h"
  25 #include "printing/printed_document.h"
  26 #include "printing/printed_page.h"
  27 #include "printing/printing_utils.h"
  28 #include "ui/base/l10n/l10n_util.h"
  29
  30 #if defined(OS_ANDROID)
  31 #include "chrome/browser/android/tab_android.h"
  32 #endif
  33
  34 using content::BrowserThread;
  35
  36 namespace printing {
  37
  38 namespace {
  39
  40 // Helper function to ensure |owner| is valid until at least |callback| returns.
  41 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
  42                      const base::Closure& callback) {
  43   callback.Run();
  44 }
  45
  46 class PrintingContextDelegate : public PrintingContext::Delegate {
  47  public:
  48   PrintingContextDelegate(int render_process_id, int render_view_id);
  49   ~PrintingContextDelegate() override;
  50
  51   gfx::NativeView GetParentView() override;
  52   std::string GetAppLocale() override;
  53
  54   // Not exposed to PrintingContext::Delegate because of dependency issues.
  55   content::WebContents* GetWebContents();
  56
  57  private:
  58   int render_process_id_;
  59   int render_view_id_;
  60 };
  61
  62 PrintingContextDelegate::PrintingContextDelegate(int render_process_id,
  63                                                  int render_view_id)
  64     : render_process_id_(render_process_id),
  65       render_view_id_(render_view_id) {
  66 }
  67
  68 PrintingContextDelegate::~PrintingContextDelegate() {
  69 }
  70
  71 gfx::NativeView PrintingContextDelegate::GetParentView() {
  72   content::WebContents* wc = GetWebContents();
  73   return wc ? wc->GetNativeView() : nullptr;
  74 }
  75
  76 content::WebContents* PrintingContextDelegate::GetWebContents() {
  77   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  78   content::RenderViewHost* view =
  79       content::RenderViewHost::FromID(render_process_id_, render_view_id_);
  80   return view ? content::WebContents::FromRenderViewHost(view) : nullptr;
  81 }
  82
  83 std::string PrintingContextDelegate::GetAppLocale() {
  84   return g_browser_process->GetApplicationLocale();
  85 }
  86
  87 void NotificationCallback(PrintJobWorkerOwner* print_job,
  88                           JobEventDetails::Type detail_type,
  89                           PrintedDocument* document,
  90                           PrintedPage* page) {
  91   JobEventDetails* details = new JobEventDetails(detail_type, document, page);
  92   content::NotificationService::current()->Notify(
  93       chrome::NOTIFICATION_PRINT_JOB_EVENT,
  94       // We know that is is a PrintJob object in this circumstance.
  95       content::Source<PrintJob>(static_cast<PrintJob*>(print_job)),
  96       content::Details<JobEventDetails>(details));
  97 }
  98
  99 void PostOnOwnerThread(const scoped_refptr<PrintJobWorkerOwner>& owner,
 100                        const PrintingContext::PrintSettingsCallback& callback,
 101                        PrintingContext::Result result) {
 102   owner->PostTask(FROM_HERE, base::Bind(&HoldRefCallback, owner,
 103                                         base::Bind(callback, result)));
 104 }
 105
 106 }  // namespace
 107
 108 PrintJobWorker::PrintJobWorker(int render_process_id,
 109                                int render_view_id,
 110                                PrintJobWorkerOwner* owner)
 111     : owner_(owner), thread_("Printing_Worker"), weak_factory_(this) {
 112   // The object is created in the IO thread.
 113   DCHECK(owner_->RunsTasksOnCurrentThread());
 114
 115   printing_context_delegate_.reset(
 116       new PrintingContextDelegate(render_process_id, render_view_id));
 117   printing_context_ = PrintingContext::Create(printing_context_delegate_.get());
 118 }
 119
 120 PrintJobWorker::~PrintJobWorker() {
 121   // The object is normally deleted in the UI thread, but when the user
 122   // cancels printing or in the case of print preview, the worker is destroyed
 123   // on the I/O thread.
 124   DCHECK(owner_->RunsTasksOnCurrentThread());
 125   Stop();
 126 }
 127
 128 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
 129   DCHECK(page_number_ == PageNumber::npos());
 130   owner_ = new_owner;
 131 }
 132
 133 void PrintJobWorker::GetSettings(
 134     bool ask_user_for_settings,
 135     int document_page_count,
 136     bool has_selection,
 137     MarginType margin_type,
 138     bool is_scripted) {
 139   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 140   DCHECK_EQ(page_number_, PageNumber::npos());
 141
 142   // Recursive task processing is needed for the dialog in case it needs to be
 143   // destroyed by a task.
 144   // TODO(thestig): This code is wrong. SetNestableTasksAllowed(true) is needed
 145   // on the thread where the PrintDlgEx is called, and definitely both calls
 146   // should happen on the same thread. See http://crbug.com/73466
 147   // MessageLoop::current()->SetNestableTasksAllowed(true);
 148   printing_context_->set_margin_type(margin_type);
 149
 150   // When we delegate to a destination, we don't ask the user for settings.
 151   // TODO(mad): Ask the destination for settings.
 152   if (ask_user_for_settings) {
 153     BrowserThread::PostTask(
 154         BrowserThread::UI, FROM_HERE,
 155         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
 156                    base::Bind(&PrintJobWorker::GetSettingsWithUI,
 157                               base::Unretained(this),
 158                               document_page_count,
 159                               has_selection,
 160                               is_scripted)));
 161   } else {
 162     BrowserThread::PostTask(
 163         BrowserThread::UI, FROM_HERE,
 164         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
 165                    base::Bind(&PrintJobWorker::UseDefaultSettings,
 166                               base::Unretained(this))));
 167   }
 168 }
 169
 170 void PrintJobWorker::SetSettings(
 171     scoped_ptr<base::DictionaryValue> new_settings) {
 172   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 173
 174   BrowserThread::PostTask(
 175       BrowserThread::UI,
 176       FROM_HERE,
 177       base::Bind(&HoldRefCallback,
 178                  make_scoped_refptr(owner_),
 179                  base::Bind(&PrintJobWorker::UpdatePrintSettings,
 180                             base::Unretained(this),
 181                             base::Passed(&new_settings))));
 182 }
 183
 184 void PrintJobWorker::UpdatePrintSettings(
 185     scoped_ptr<base::DictionaryValue> new_settings) {
 186   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 187   PrintingContext::Result result =
 188       printing_context_->UpdatePrintSettings(*new_settings);
 189   GetSettingsDone(result);
 190 }
 191
 192 void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
 193   // Most PrintingContext functions may start a message loop and process
 194   // message recursively, so disable recursive task processing.
 195   // TODO(thestig): See above comment. SetNestableTasksAllowed(false) needs to
 196   // be called on the same thread as the previous call.  See
 197   // http://crbug.com/73466
 198   // MessageLoop::current()->SetNestableTasksAllowed(false);
 199
 200   // We can't use OnFailure() here since owner_ may not support notifications.
 201
 202   // PrintJob will create the new PrintedDocument.
 203   owner_->PostTask(FROM_HERE,
 204                    base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
 205                               make_scoped_refptr(owner_),
 206                               printing_context_->settings(),
 207                               result));
 208 }
 209
 210 void PrintJobWorker::GetSettingsWithUI(
 211     int document_page_count,
 212     bool has_selection,
 213     bool is_scripted) {
 214   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 215
 216 #if defined(OS_ANDROID)
 217   if (is_scripted) {
 218     PrintingContextDelegate* printing_context_delegate =
 219         static_cast<PrintingContextDelegate*>(printing_context_delegate_.get());
 220     content::WebContents* web_contents =
 221         printing_context_delegate->GetWebContents();
 222     TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
 223
 224     // Regardless of whether the following call fails or not, the javascript
 225     // call will return since startPendingPrint will make it return immediately
 226     // in case of error.
 227     if (tab)
 228       tab->SetPendingPrint();
 229   }
 230 #endif
 231
 232   // weak_factory_ creates pointers valid only on owner_ thread.
 233   printing_context_->AskUserForSettings(
 234       document_page_count, has_selection, is_scripted,
 235       base::Bind(&PostOnOwnerThread, make_scoped_refptr(owner_),
 236                  base::Bind(&PrintJobWorker::GetSettingsDone,
 237                             weak_factory_.GetWeakPtr())));
 238 }
 239
 240 void PrintJobWorker::UseDefaultSettings() {
 241   PrintingContext::Result result = printing_context_->UseDefaultSettings();
 242   GetSettingsDone(result);
 243 }
 244
 245 void PrintJobWorker::StartPrinting(PrintedDocument* new_document) {
 246   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 247   DCHECK_EQ(page_number_, PageNumber::npos());
 248   DCHECK_EQ(document_.get(), new_document);
 249   DCHECK(document_.get());
 250
 251   if (!document_.get() || page_number_ != PageNumber::npos() ||
 252       document_.get() != new_document) {
 253     return;
 254   }
 255
 256   base::string16 document_name =
 257       printing::SimplifyDocumentTitle(document_->name());
 258   if (document_name.empty()) {
 259     document_name = printing::SimplifyDocumentTitle(
 260         l10n_util::GetStringUTF16(IDS_DEFAULT_PRINT_DOCUMENT_TITLE));
 261   }
 262   PrintingContext::Result result =
 263       printing_context_->NewDocument(document_name);
 264   if (result != PrintingContext::OK) {
 265     OnFailure();
 266     return;
 267   }
 268
 269   // Try to print already cached data. It may already have been generated for
 270   // the print preview.
 271   OnNewPage();
 272   // Don't touch this anymore since the instance could be destroyed. It happens
 273   // if all the pages are printed a one sweep and the client doesn't have a
 274   // handle to us anymore. There's a timing issue involved between the worker
 275   // thread and the UI thread. Take no chance.
 276 }
 277
 278 void PrintJobWorker::OnDocumentChanged(PrintedDocument* new_document) {
 279   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 280   DCHECK_EQ(page_number_, PageNumber::npos());
 281
 282   if (page_number_ != PageNumber::npos())
 283     return;
 284
 285   document_ = new_document;
 286 }
 287
 288 void PrintJobWorker::OnNewPage() {
 289   if (!document_.get())  // Spurious message.
 290     return;
 291
 292   // message_loop() could return NULL when the print job is cancelled.
 293   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 294
 295   if (page_number_ == PageNumber::npos()) {
 296     // Find first page to print.
 297     int page_count = document_->page_count();
 298     if (!page_count) {
 299       // We still don't know how many pages the document contains. We can't
 300       // start to print the document yet since the header/footer may refer to
 301       // the document's page count.
 302       return;
 303     }
 304     // We have enough information to initialize page_number_.
 305     page_number_.Init(document_->settings(), page_count);
 306   }
 307   DCHECK_NE(page_number_, PageNumber::npos());
 308
 309   while (true) {
 310     // Is the page available?
 311     scoped_refptr<PrintedPage> page = document_->GetPage(page_number_.ToInt());
 312     if (!page.get()) {
 313       // We need to wait for the page to be available.
 314       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 315           FROM_HERE,
 316           base::Bind(&PrintJobWorker::OnNewPage, weak_factory_.GetWeakPtr()),
 317           base::TimeDelta::FromMilliseconds(500));
 318       break;
 319     }
 320     // The page is there, print it.
 321     SpoolPage(page.get());
 322     ++page_number_;
 323     if (page_number_ == PageNumber::npos()) {
 324       OnDocumentDone();
 325       // Don't touch this anymore since the instance could be destroyed.
 326       break;
 327     }
 328   }
 329 }
 330
 331 void PrintJobWorker::Cancel() {
 332   // This is the only function that can be called from any thread.
 333   printing_context_->Cancel();
 334   // Cannot touch any member variable since we don't know in which thread
 335   // context we run.
 336 }
 337
 338 bool PrintJobWorker::IsRunning() const {
 339   return thread_.IsRunning();
 340 }
 341
 342 bool PrintJobWorker::PostTask(const tracked_objects::Location& from_here,
 343                               const base::Closure& task) {
 344   if (task_runner_.get())
 345     return task_runner_->PostTask(from_here, task);
 346   return false;
 347 }
 348
 349 void PrintJobWorker::StopSoon() {
 350   thread_.StopSoon();
 351 }
 352
 353 void PrintJobWorker::Stop() {
 354   thread_.Stop();
 355 }
 356
 357 bool PrintJobWorker::Start() {
 358   bool result = thread_.Start();
 359   task_runner_ = thread_.task_runner();
 360   return result;
 361 }
 362
 363 void PrintJobWorker::OnDocumentDone() {
 364   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 365   DCHECK_EQ(page_number_, PageNumber::npos());
 366   DCHECK(document_.get());
 367
 368   if (printing_context_->DocumentDone() != PrintingContext::OK) {
 369     OnFailure();
 370     return;
 371   }
 372
 373   owner_->PostTask(FROM_HERE,
 374                    base::Bind(&NotificationCallback,
 375                               make_scoped_refptr(owner_),
 376                               JobEventDetails::DOC_DONE,
 377                               document_,
 378                               scoped_refptr<PrintedPage>()));
 379
 380   // Makes sure the variables are reinitialized.
 381   document_ = NULL;
 382 }
 383
 384 void PrintJobWorker::SpoolPage(PrintedPage* page) {
 385   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 386   DCHECK_NE(page_number_, PageNumber::npos());
 387
 388   // Signal everyone that the page is about to be printed.
 389   owner_->PostTask(FROM_HERE,
 390                    base::Bind(&NotificationCallback,
 391                               make_scoped_refptr(owner_),
 392                               JobEventDetails::NEW_PAGE,
 393                               document_,
 394                               make_scoped_refptr(page)));
 395
 396   // Preprocess.
 397   if (printing_context_->NewPage() != PrintingContext::OK) {
 398     OnFailure();
 399     return;
 400   }
 401
 402   // Actual printing.
 403 #if defined(OS_WIN) || defined(OS_MACOSX)
 404   document_->RenderPrintedPage(*page, printing_context_->context());
 405 #elif defined(OS_POSIX)
 406   document_->RenderPrintedPage(*page, printing_context_.get());
 407 #endif
 408
 409   // Postprocess.
 410   if (printing_context_->PageDone() != PrintingContext::OK) {
 411     OnFailure();
 412     return;
 413   }
 414
 415   // Signal everyone that the page is printed.
 416   owner_->PostTask(FROM_HERE,
 417                    base::Bind(&NotificationCallback,
 418                               make_scoped_refptr(owner_),
 419                               JobEventDetails::PAGE_DONE,
 420                               document_,
 421                               make_scoped_refptr(page)));
 422 }
 423
 424 void PrintJobWorker::OnFailure() {
 425   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 426
 427   // We may loose our last reference by broadcasting the FAILED event.
 428   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 429
 430   owner_->PostTask(FROM_HERE,
 431                    base::Bind(&NotificationCallback,
 432                               make_scoped_refptr(owner_),
 433                               JobEventDetails::FAILED,
 434                               document_,
 435                               scoped_refptr<PrintedPage>()));
 436   Cancel();
 437
 438   // Makes sure the variables are reinitialized.
 439   document_ = NULL;
 440   page_number_ = PageNumber::npos();
 441 }
 442
 443 }  // namespace printing