Add Postscript Printing

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"
@@ skipping 206 matching lines @@
   return is_job_pending_;
 }
 
 PrintedDocument* PrintJob::document() const {
   return document_.get();
 }
 
 #if defined(OS_WIN)
 class PrintJob::PdfConversionState {
  public:
-  PdfConversionState(gfx::Size page_size,
-                     gfx::Rect content_area,
-                     std::unique_ptr<PdfConverter> converter)
+  PdfConversionState(gfx::Size page_size, gfx::Rect content_area)
       : page_count_(0),
         current_page_(0),
         pages_in_progress_(0),
         page_size_(page_size),
-        content_area_(content_area),
-        converter_(std::move(converter)) {}
+        content_area_(content_area) {}
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfRenderSettings& conversion_settings,
              const PdfConverter::StartCallback& start_callback) {
-    converter_->Start(data, conversion_settings, start_callback);
+    converter_ = PdfConverter::StartPdfConverter(
+          data, conversion_settings, start_callback);
   }
 
   void GetMorePages(const PdfConverter::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);
     }
   }
@@ skipping 23 matching lines @@
   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,
     bool print_text_with_gdi) {
   DCHECK(!pdf_conversion_state_);
   pdf_conversion_state_ =
-      base::MakeUnique<PdfConversionState>(page_size, content_area,
-          PdfConverter::CreatePdfToEmfConverter());
+      base::MakeUnique<PdfConversionState>(page_size, content_area);
   const int kPrinterDpi = settings().dpi();
   PdfRenderSettings settings(
-      content_area, kPrinterDpi, /*autorotate=*/true,
+      content_area, gfx::Point(0,0), kPrinterDpi, /*autorotate=*/true,
       print_text_with_gdi ? PdfRenderSettings::Mode::GDI_TEXT
                           : PdfRenderSettings::Mode::NORMAL);
   pdf_conversion_state_->Start(
-      bytes, settings,
-      base::Bind(&PrintJob::OnPdfConversionStarted, this));
+      bytes, settings, base::Bind(&PrintJob::OnPdfConversionStarted, this));
 }
 
 void PrintJob::OnPdfConversionStarted(int page_count) {
   if (page_count <= 0) {
     pdf_conversion_state_.reset();
     Cancel();
     return;
   }
   pdf_conversion_state_->set_page_count(page_count);
   pdf_conversion_state_->GetMorePages(
@@ skipping 12 matching lines @@
   }
 
   // Update the rendered document. It will send notifications to the listener.
   document_->SetPage(pdf_page_mapping_[page_number], std::move(metafile),
                      scale_factor, pdf_conversion_state_->page_size(),
                      pdf_conversion_state_->content_area());
 
   pdf_conversion_state_->GetMorePages(
       base::Bind(&PrintJob::OnPdfPageConverted, this));
 }
+
+void PrintJob::StartPdfToPostScriptConversion(
+    const scoped_refptr<base::RefCountedMemory>& bytes,
+    const gfx::Rect& content_area,
+    const gfx::Point& physical_offsets,
+    bool ps_level2) {
+  DCHECK(!pdf_conversion_state_);
+  pdf_conversion_state_ = base::MakeUnique<PdfConversionState>(
+      gfx::Size(), gfx::Rect());
+  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_conversion_state_->Start(
+      bytes, settings, base::Bind(&PrintJob::OnPdfConversionStarted, this));
+}
 #endif  // defined(OS_WIN)
 
 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (document_.get() == new_document)
     return;
 
   document_ = new_document;
 
   if (document_.get())
     settings_ = document_->settings();
@@ skipping 125 matching lines @@
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing