Add Postscript Printing

chrome/browser/printing/print_job.cc

Index: chrome/browser/printing/print_job.cc
diff --git a/chrome/browser/printing/print_job.cc b/chrome/browser/printing/print_job.cc
index 70bdb9004589a6d943d0d19c9ef62c9328cff8eb..611e3b213fdd6b5b75fd209ee3025d47d5bb9229 100644
--- a/chrome/browser/printing/print_job.cc
+++ b/chrome/browser/printing/print_job.cc
@@ -235,10 +235,8 @@ class PrintJob::PdfToEmfState {
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfRenderSettings& conversion_settings,
-             bool print_text_with_gdi,
              const PdfToEmfConverter::StartCallback& start_callback) {
-    converter_->Start(data, conversion_settings, print_text_with_gdi,
-                      start_callback);
+    converter_->Start(data, conversion_settings, start_callback);
   }
 
   void GetMorePages(
@@ -261,8 +259,8 @@ class PrintJob::PdfToEmfState {
   }
 
   void set_page_count(int page_count) { page_count_ = page_count; }
-  gfx::Size page_size() const { return page_size_; }
-  gfx::Rect content_area() const { return content_area_; }
+  const gfx::Size& page_size() const { return page_size_; }
+  const gfx::Rect& content_area() const { return content_area_; }
 
  private:
   int page_count_;
@@ -273,6 +271,48 @@ class PrintJob::PdfToEmfState {
   std::unique_ptr<PdfToEmfConverter> converter_;
 };
 
+class PrintJob::PdfToPostScriptState {
+ public:
+  PdfToPostScriptState()
+      : page_count_(0),
+        current_page_(0),
+        pages_in_progress_(0),
+        converter_(PdfToPostScriptConverter::CreateDefault()) {}
+
+  void Start(const scoped_refptr<base::RefCountedMemory>& data,
+             const PdfRenderSettings& conversion_settings,
+             const PdfToPostScriptConverter::StartCallback& start_callback) {
+    converter_->Start(data, conversion_settings, start_callback);
+  }
+
+  void GetMorePages(
+      const PdfToPostScriptConverter::GetPageCallback& get_page_callback) {
+    const int kMaxNumberOfTempFilesPerDocument = 3;
+    while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
+           current_page_ < page_count_) {
+      ++pages_in_progress_;
+      converter_->GetPage(current_page_++, get_page_callback);
+    }
+  }
+
+  void OnPageProcessed(
+      const PdfToPostScriptConverter::GetPageCallback& get_page_callback) {
+    --pages_in_progress_;
+    GetMorePages(get_page_callback);
+    // Release converter if we don't need this any more.
+    if (!pages_in_progress_ && current_page_ >= page_count_)
+      converter_.reset();

[dsinclair, 2017/01/17 17:10:00]

Shoudl this be .reset(PdfToPostScriptConverter::CreateDefault()) so the convert
is ready to go again instead of being a nullptr?

We'll currently crash if Start is called a second time with this state object,
or is that just not allowed?

+  }
+
+  void set_page_count(int page_count) { page_count_ = page_count; }
+
+ private:
+  int page_count_;
+  int current_page_;
+  int pages_in_progress_;
+  std::unique_ptr<PdfToPostScriptConverter> converter_;
+};
+
 void PrintJob::AppendPrintedPage(int page_number) {
   pdf_page_mapping_.push_back(page_number);
 }
@@ -285,9 +325,12 @@ void PrintJob::StartPdfToEmfConversion(
   DCHECK(!pdf_to_emf_state_);
   pdf_to_emf_state_ = base::MakeUnique<PdfToEmfState>(page_size, content_area);
   const int kPrinterDpi = settings().dpi();
-  pdf_to_emf_state_->Start(
-      bytes, PdfRenderSettings(content_area, kPrinterDpi, true),
-      print_text_with_gdi, base::Bind(&PrintJob::OnPdfToEmfStarted, this));
+  PdfRenderSettings settings(
+      content_area, gfx::Point(0, 0), kPrinterDpi, true /* autorotate? */,
+      print_text_with_gdi ? PdfRenderSettings::Mode::GDI_TEXT
+                          : PdfRenderSettings::Mode::NORMAL);
+  pdf_to_emf_state_->Start(bytes, settings,
+                           base::Bind(&PrintJob::OnPdfToEmfStarted, this));
 }
 
 void PrintJob::OnPdfToEmfStarted(int page_count) {
@@ -321,7 +364,54 @@ void PrintJob::OnPdfToEmfPageConverted(int page_number,
       base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
 }
 
-#endif  // OS_WIN
+void PrintJob::StartPdfToPostScriptConversion(
+    const scoped_refptr<base::RefCountedMemory>& bytes,
+    const gfx::Rect& content_area,
+    const gfx::Point& physical_offsets,
+    bool ps_level2) {
+  DCHECK(!pdf_to_ps_state_);
+  pdf_to_ps_state_ = base::MakeUnique<PdfToPostScriptState>();
+  const int kPrinterDpi = settings().dpi();
+  PdfRenderSettings settings(
+      content_area, physical_offsets, kPrinterDpi, true /* autorotate? */,
+      ps_level2 ? PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2
+                : PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3);
+  pdf_to_ps_state_->Start(
+      bytes, settings, base::Bind(&PrintJob::OnPdfToPostScriptStarted, this));
+}
+
+void PrintJob::OnPdfToPostScriptStarted(int page_count) {
+  if (page_count <= 0) {
+    pdf_to_ps_state_.reset();
+    Cancel();
+    return;
+  }
+  pdf_to_ps_state_->set_page_count(page_count);
+  pdf_to_ps_state_->GetMorePages(
+      base::Bind(&PrintJob::OnPdfToPostScriptPageConverted, this));
+}
+
+void PrintJob::OnPdfToPostScriptPageConverted(
+    int page_number,
+    std::unique_ptr<MetafilePlayer> ps_metafile) {
+  DCHECK(pdf_to_ps_state_);
+  if (!document_.get() || !ps_metafile || page_number < 0 ||
+      static_cast<size_t>(page_number) >= pdf_page_mapping_.size()) {
+    pdf_to_ps_state_.reset();
+    Cancel();
+    return;
+  }
+
+  // Update the rendered document. It will send notifications to the listener.
+  document_->SetPage(pdf_page_mapping_[page_number], std::move(ps_metafile),
+                     0 /* dummy shrink_factor */,
+                     gfx::Size() /* dummy page_size */,
+                     gfx::Rect() /* dummy page_content_rect */);
+
+  pdf_to_ps_state_->GetMorePages(
+      base::Bind(&PrintJob::OnPdfToPostScriptPageConverted, this));
+}
+#endif  // defined(OS_WIN)
 
 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (document_.get() == new_document)
@@ -372,9 +462,14 @@ void PrintJob::OnNotifyPrintJobEvent(const JobEventDetails& event_details) {
     }
     case JobEventDetails::PAGE_DONE:
 #if defined(OS_WIN)
-      pdf_to_emf_state_->OnPageProcessed(
-          base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
-#endif  // defined(OS_WIN)
+      if (pdf_to_emf_state_) {
+        pdf_to_emf_state_->OnPageProcessed(
+            base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
+      } else {
+        pdf_to_ps_state_->OnPageProcessed(
+            base::Bind(&PrintJob::OnPdfToPostScriptPageConverted, this));
+      }
+#endif
       break;
     default: {
       NOTREACHED();