Win: Fix printing selected pages with native dialog.

chrome/browser/printing/print_job.cc

 // Copyright (c) 2012 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.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/printing/print_job_worker.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "printing/printed_document.h"
 #include "printing/printed_page.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/printing/pdf_to_emf_converter.h"
 #include "printing/pdf_render_settings.h"
 #endif
 
 using base::TimeDelta;
 
+namespace printing {
+
 namespace {
 
 // Helper function to ensure |owner| is valid until at least |callback| returns.
-void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
+void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
                      const base::Closure& callback) {
   callback.Run();
 }
 
 }  // namespace
 
-namespace printing {
-
 PrintJob::PrintJob()
-    : source_(NULL),
-      worker_(),
-      settings_(),
+    : source_(nullptr),
       is_job_pending_(false),
       is_canceling_(false),
       quit_factory_(this) {
   // This is normally a UI message loop, but in unit tests, the message loop is
   // of the 'default' type.
   DCHECK(base::MessageLoopForUI::IsCurrent() ||
          base::MessageLoop::current()->type() ==
              base::MessageLoop::TYPE_DEFAULT);
 }
 
 PrintJob::~PrintJob() {
   // The job should be finished (or at least canceled) when it is destroyed.
   DCHECK(!is_job_pending_);
   DCHECK(!is_canceling_);
   DCHECK(!worker_ || !worker_->IsRunning());
   DCHECK(RunsTasksOnCurrentThread());
 }
 
 void PrintJob::Initialize(PrintJobWorkerOwner* job,
                           PrintedPagesSource* source,
                           int page_count) {
   DCHECK(!source_);
-  DCHECK(!worker_.get());
+  DCHECK(!worker_);
   DCHECK(!is_job_pending_);
   DCHECK(!is_canceling_);
   DCHECK(!document_.get());
   source_ = source;
   worker_.reset(job->DetachWorker(this));
   settings_ = job->settings();
 
   PrintedDocument* new_doc =
       new PrintedDocument(settings_,
                           source_,
@@ skipping 16 matching lines @@
   OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
 }
 
 void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
                                PrintingContext::Result result) {
   NOTREACHED();
 }
 
 PrintJobWorker* PrintJob::DetachWorker(PrintJobWorkerOwner* new_owner) {
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 const PrintSettings& PrintJob::settings() const {
   return settings_;
 }
 
 int PrintJob::cookie() const {
+  // Always use an invalid cookie in this case.
   if (!document_.get())
-    // Always use an invalid cookie in this case.
     return 0;
   return document_->cookie();
 }
 
 void PrintJob::StartPrinting() {
   DCHECK(RunsTasksOnCurrentThread());
-  DCHECK(worker_->IsRunning());
-  DCHECK(!is_job_pending_);
-  if (!worker_->IsRunning() || is_job_pending_)
+  if (!worker_->IsRunning() || is_job_pending_) {
+    NOTREACHED();
     return;
+  }
 
   // Real work is done in PrintJobWorker::StartPrinting().
   worker_->PostTask(FROM_HERE,
                     base::Bind(&HoldRefCallback, make_scoped_refptr(this),
                                base::Bind(&PrintJobWorker::StartPrinting,
                                           base::Unretained(worker_.get()),
                                           base::RetainedRef(document_))));
   // Set the flag right now.
   is_job_pending_ = true;
 
   // Tell everyone!
   scoped_refptr<JobEventDetails> details(
-      new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL));
+      new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::Stop() {
   DCHECK(RunsTasksOnCurrentThread());
 
   if (quit_factory_.HasWeakPtrs()) {
@@ skipping 24 matching lines @@
   scoped_refptr<PrintJob> handle(this);
 
   DCHECK(RunsTasksOnCurrentThread());
   if (worker_ && worker_->IsRunning()) {
     // Call this right now so it renders the context invalid. Do not use
     // InvokeLater since it would take too much time.
     worker_->Cancel();
   }
   // Make sure a Cancel() is broadcast.
   scoped_refptr<JobEventDetails> details(
-      new JobEventDetails(JobEventDetails::FAILED, NULL, NULL));
+      new JobEventDetails(JobEventDetails::FAILED, nullptr, nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
   Stop();
   is_canceling_ = false;
 }
 
 bool PrintJob::FlushJob(base::TimeDelta timeout) {
   // Make sure the object outlive this message loop.
   scoped_refptr<PrintJob> handle(this);
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&PrintJob::Quit, quit_factory_.GetWeakPtr()),
       timeout);
 
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
   base::RunLoop().Run();
 
   return true;
 }
 
 void PrintJob::DisconnectSource() {
-  source_ = NULL;
+  source_ = nullptr;
   if (document_.get())
     document_->DisconnectSource();
 }
 
 bool PrintJob::is_job_pending() const {
   return is_job_pending_;
 }
 
 PrintedDocument* PrintJob::document() const {
   return document_.get();
@@ skipping 42 matching lines @@
 
  private:
   int page_count_;
   int current_page_;
   int pages_in_progress_;
   gfx::Size page_size_;
   gfx::Rect content_area_;
   std::unique_ptr<PdfToEmfConverter> converter_;
 };
 
+void PrintJob::AppendPrintedPage(int page_number) {
+  pdf_page_mapping_.push_back(page_number);
+}
+
 void PrintJob::StartPdfToEmfConversion(
     const scoped_refptr<base::RefCountedMemory>& bytes,
     const gfx::Size& page_size,
     const gfx::Rect& content_area) {
-  DCHECK(!ptd_to_emf_state_.get());
-  ptd_to_emf_state_.reset(new PdfToEmfState(page_size, content_area));
+  DCHECK(!pdf_to_emf_state_);
+  pdf_to_emf_state_ = base::MakeUnique<PdfToEmfState>(page_size, content_area);
   const int kPrinterDpi = settings().dpi();
-  ptd_to_emf_state_->Start(
-      bytes,
-      printing::PdfRenderSettings(content_area, kPrinterDpi, true),
-      base::Bind(&PrintJob::OnPdfToEmfStarted, this));
+  pdf_to_emf_state_->Start(bytes,
+                           PdfRenderSettings(content_area, kPrinterDpi, true),
+                           base::Bind(&PrintJob::OnPdfToEmfStarted, this));
 }
 
 void PrintJob::OnPdfToEmfStarted(int page_count) {
   if (page_count <= 0) {
-    ptd_to_emf_state_.reset();
+    pdf_to_emf_state_.reset();
     Cancel();
     return;
   }
-  ptd_to_emf_state_->set_page_count(page_count);
-  ptd_to_emf_state_->GetMorePages(
+  pdf_to_emf_state_->set_page_count(page_count);
+  pdf_to_emf_state_->GetMorePages(
       base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 }
 
 void PrintJob::OnPdfToEmfPageConverted(int page_number,
                                        float scale_factor,
                                        std::unique_ptr<MetafilePlayer> emf) {
-  DCHECK(ptd_to_emf_state_);
-  if (!document_.get() || !emf) {
-    ptd_to_emf_state_.reset();
+  DCHECK(pdf_to_emf_state_);
+  if (!document_.get() || !emf || page_number < 0 ||
+      static_cast<size_t>(page_number) >= pdf_page_mapping_.size()) {
+    pdf_to_emf_state_.reset();
     Cancel();
     return;
   }
 
   // Update the rendered document. It will send notifications to the listener.
-  document_->SetPage(page_number, std::move(emf), scale_factor,
-                     ptd_to_emf_state_->page_size(),
-                     ptd_to_emf_state_->content_area());
+  document_->SetPage(pdf_page_mapping_[page_number], std::move(emf),
+                     scale_factor, pdf_to_emf_state_->page_size(),
+                     pdf_to_emf_state_->content_area());
 
-  ptd_to_emf_state_->GetMorePages(
+  pdf_to_emf_state_->GetMorePages(
       base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 }
 
 #endif  // OS_WIN
 
 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (document_.get() == new_document)
     return;
 
   document_ = new_document;
 
-  if (document_.get()) {
+  if (document_.get())
     settings_ = document_->settings();
-  }
 
   if (worker_) {
     DCHECK(!is_job_pending_);
     // Sync the document with the worker.
     worker_->PostTask(FROM_HERE,
                       base::Bind(&HoldRefCallback, make_scoped_refptr(this),
                                  base::Bind(&PrintJobWorker::OnDocumentChanged,
                                             base::Unretained(worker_.get()),
                                             base::RetainedRef(document_))));
   }
@@ skipping 21 matching lines @@
       break;
     }
     case JobEventDetails::DOC_DONE: {
       // This will call Stop() and broadcast a JOB_DONE message.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&PrintJob::OnDocumentDone, this));
       break;
     }
     case JobEventDetails::PAGE_DONE:
 #if defined(OS_WIN)
-      ptd_to_emf_state_->OnPageProcessed(
+      pdf_to_emf_state_->OnPageProcessed(
           base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
-#endif  // OS_WIN
+#endif  // defined(OS_WIN)
       break;
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void PrintJob::OnDocumentDone() {
   // Be sure to live long enough. The instance could be destroyed by the
   // JOB_DONE broadcast.
   scoped_refptr<PrintJob> handle(this);
 
   // Stop the worker thread.
   Stop();
 
   scoped_refptr<JobEventDetails> details(
-      new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), NULL));
+      new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), nullptr));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::ControlledWorkerShutdown() {
   DCHECK(RunsTasksOnCurrentThread());
 
   // The deadlock this code works around is specific to window messaging on
@@ skipping 51 matching lines @@
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing