Add Postscript Printing

chrome/utility/printing_handler.cc

 // Copyright 2014 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/utility/printing_handler.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 71 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 #if defined(OS_WIN)
 void PrintingHandler::OnRenderPDFPagesToMetafile(
     IPC::PlatformFileForTransit pdf_transit,
     const PdfRenderSettings& settings) {
   pdf_rendering_settings_ = settings;
+  chrome_pdf::SetPDFPostscriptPrintingLevel(0);  // Not using postscript.
   chrome_pdf::SetPDFUseGDIPrinting(pdf_rendering_settings_.mode ==
                                    PdfRenderSettings::Mode::GDI_TEXT);
+  if (pdf_rendering_settings_.mode ==
+      PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2) {
+    chrome_pdf::SetPDFPostscriptPrintingLevel(2);
+  } else if (pdf_rendering_settings_.mode ==
+             PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3) {
+    chrome_pdf::SetPDFPostscriptPrintingLevel(3);
+  }
   base::File pdf_file = IPC::PlatformFileForTransitToFile(pdf_transit);
   int page_count = LoadPDF(std::move(pdf_file));
   Send(
       new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount(page_count));
 }
 
 void PrintingHandler::OnRenderPDFPagesToMetafileGetPage(
     int page_number,
     IPC::PlatformFileForTransit output_file) {
   base::File emf_file = IPC::PlatformFileForTransitToFile(output_file);
   float scale_factor = 1.0f;
-  bool success =
-      RenderPdfPageToMetafile(page_number, std::move(emf_file), &scale_factor);
+  bool postscript = pdf_rendering_settings_.mode ==
+                        PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2 ||
+                    pdf_rendering_settings_.mode ==
+                        PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3;
+  bool success = RenderPdfPageToMetafile(page_number, std::move(emf_file),
+                                         &scale_factor, postscript);
   Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone(
       success, scale_factor));
 }
 
 void PrintingHandler::OnRenderPDFPagesToMetafileStop() {
   ReleaseProcessIfNeeded();
 }
 
-#endif  // OS_WIN
+#endif  // defined(OS_WIN)
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintingHandler::OnRenderPDFPagesToPWGRaster(
     IPC::PlatformFileForTransit pdf_transit,
     const PdfRenderSettings& settings,
     const PwgRasterSettings& bitmap_settings,
     IPC::PlatformFileForTransit bitmap_transit) {
   base::File pdf = IPC::PlatformFileForTransitToFile(pdf_transit);
   base::File bitmap = IPC::PlatformFileForTransitToFile(bitmap_transit);
   if (RenderPDFPagesToPWGRaster(std::move(pdf), settings, bitmap_settings,
                                 std::move(bitmap))) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Succeeded());
   } else {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Failed());
   }
   ReleaseProcessIfNeeded();
 }
-#endif  // ENABLE_PRINT_PREVIEW
+#endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 #if defined(OS_WIN)
 int PrintingHandler::LoadPDF(base::File pdf_file) {
   int64_t length64 = pdf_file.GetLength();
   if (length64 <= 0 || length64 > std::numeric_limits<int>::max())
     return 0;
   int length = static_cast<int>(length64);
 
   pdf_data_.resize(length);
   if (length != pdf_file.Read(0, pdf_data_.data(), pdf_data_.size()))
     return 0;
 
   int total_page_count = 0;
   if (!chrome_pdf::GetPDFDocInfo(&pdf_data_.front(), pdf_data_.size(),
                                  &total_page_count, nullptr)) {
     return 0;
   }
   return total_page_count;
 }
 
 bool PrintingHandler::RenderPdfPageToMetafile(int page_number,
                                               base::File output_file,
-                                              float* scale_factor) {
+                                              float* scale_factor,
+                                              bool postscript) {
   Emf metafile;
   metafile.Init();
 
   // We need to scale down DC to fit an entire page into DC available area.
   // Current metafile is based on screen DC and have current screen size.
   // Writing outside of those boundaries will result in the cut-off output.
   // On metafiles (this is the case here), scaling down will still record
   // original coordinates and we'll be able to print in full resolution.
   // Before playback we'll need to counter the scaling up that will happen
   // in the service (print_system_win.cc).
-  *scale_factor = gfx::CalculatePageScale(
-      metafile.context(), pdf_rendering_settings_.area.right(),
-      pdf_rendering_settings_.area.bottom());
-  gfx::ScaleDC(metafile.context(), *scale_factor);
+  //
+  // The postscript driver does not use the metafile size since it outputs
+  // postscript rather than a metafile. Instead it uses the printable area
+  // sent to RenderPDFPageToDC to determine the area to render. Therefore,
+  // don't scale the DC to match the metafile, and send the printer physical
+  // offsets to the driver.
+  if (!postscript) {
+    *scale_factor = gfx::CalculatePageScale(
+        metafile.context(), pdf_rendering_settings_.area.right(),
+        pdf_rendering_settings_.area.bottom());
+    gfx::ScaleDC(metafile.context(), *scale_factor);
+  }
 
   // The underlying metafile is of type Emf and ignores the arguments passed
   // to StartPage.
   metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
+  int offset_x = postscript ? pdf_rendering_settings_.offsets.x() : 0;
+  int offset_y = postscript ? pdf_rendering_settings_.offsets.y() : 0;
+
   if (!chrome_pdf::RenderPDFPageToDC(
           &pdf_data_.front(), pdf_data_.size(), page_number, metafile.context(),
-          pdf_rendering_settings_.dpi, pdf_rendering_settings_.area.x(),
-          pdf_rendering_settings_.area.y(),
+          pdf_rendering_settings_.dpi,
+          pdf_rendering_settings_.area.x() - offset_x,
+          pdf_rendering_settings_.area.y() - offset_y,
           pdf_rendering_settings_.area.width(),
           pdf_rendering_settings_.area.height(), true, false, true, true,
           pdf_rendering_settings_.autorotate)) {
     return false;
   }
   metafile.FinishPage();
   metafile.FinishDocument();
   return metafile.SaveTo(&output_file);
 }
 #endif  // defined(OS_WIN)
@@ skipping 113 matching lines @@
   if (print_backend->GetPrinterSemanticCapsAndDefaults(printer_name,
                                                        &printer_info)) {
     Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded(
         printer_name, printer_info));
   } else {
     Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed(
         printer_name));
   }
   ReleaseProcessIfNeeded();
 }
-#endif  // ENABLE_PRINT_PREVIEW
+#endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 }  // namespace printing