Printing on Windows via PDF

chrome/utility/chrome_content_utility_client.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/utility/chrome_content_utility_client.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 152 matching lines @@
       return false;
     return get_pdf_doc_info_func_(pdf_buffer, buffer_size, page_count,
                                   max_page_width);
   }
 
  protected:
   virtual bool PlatformInit(
       const base::FilePath& pdf_module_path,
       const base::ScopedNativeLibrary& pdf_lib) {
     return true;
-  };
+  }
 
  private:
   // Exported by PDF plugin.
   typedef bool (*RenderPDFPageToBitmapProc)(const void* pdf_buffer,
                                             int pdf_buffer_size,
                                             int page_number,
                                             void* bitmap_buffer,
                                             int bitmap_width,
                                             int bitmap_height,
                                             int dpi_x,
@@ skipping 172 matching lines @@
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeContentUtilityClient, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackExtension, OnUnpackExtension)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackWebResource,
                         OnUnpackWebResource)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseUpdateManifest,
                         OnParseUpdateManifest)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImage, OnDecodeImage)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImageBase64, OnDecodeImageBase64)
-    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafile,
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafiles,
                         OnRenderPDFPagesToMetafile)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToPWGRaster,
                         OnRenderPDFPagesToPWGRaster)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RobustJPEGDecodeImage,
                         OnRobustJPEGDecodeImage)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseJSON, OnParseJSON)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterCapsAndDefaults,
                         OnGetPrinterCapsAndDefaults)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults,
                         OnGetPrinterSemanticCapsAndDefaults)
@@ skipping 181 matching lines @@
 
   if (succeeded)
     Send(new ChromeUtilityHostMsg_CreateZipFile_Succeeded());
   else
     Send(new ChromeUtilityHostMsg_CreateZipFile_Failed());
   ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_CHROMEOS)
 
 void ChromeContentUtilityClient::OnRenderPDFPagesToMetafile(
-    base::PlatformFile pdf_file,
+    IPC::PlatformFileForTransit pdf_transit,
     const base::FilePath& metafile_path,
     const printing::PdfRenderSettings& settings,
-    const std::vector<printing::PageRange>& page_ranges) {
+    const std::vector<printing::PageRange>& page_ranges_const) {
   bool succeeded = false;
 #if defined(OS_WIN)
+  base::PlatformFile pdf_file =
+      IPC::PlatformFileForTransitToPlatformFile(pdf_transit);
   int highest_rendered_page_number = 0;
   double scale_factor = 1.0;
+  std::vector<printing::PageRange> page_ranges = page_ranges_const;
   succeeded = RenderPDFToWinMetafile(pdf_file,
                                      metafile_path,
                                      settings,
-                                     page_ranges,
+                                     &page_ranges,
                                      &highest_rendered_page_number,
                                      &scale_factor);
   if (succeeded) {
-    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
-        highest_rendered_page_number, scale_factor));
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_Succeeded(

[Vitaly Buka (NO REVIEWS), 2014/05/15 19:23:34]

So how about sending ChromeUtilityHostMsg_RenderPDFPageToMetafiles_Succeeded
message for each page, so we can start spool sooner?

[scottmg, 2014/05/15 19:43:04]

That should help for PdfToEmfConverter I think. It won't matter for cloud print
because the range is always 1 page here.

+        page_ranges, scale_factor));
   }
 #endif  // defined(OS_WIN)
   if (!succeeded) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
   }
   ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnRenderPDFPagesToPWGRaster(
     IPC::PlatformFileForTransit pdf_transit,
@@ skipping 10 matching lines @@
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Failed());
   }
   ReleaseProcessIfNeeded();
 }
 
 #if defined(OS_WIN)
 bool ChromeContentUtilityClient::RenderPDFToWinMetafile(
     base::PlatformFile pdf_file,
     const base::FilePath& metafile_path,
     const printing::PdfRenderSettings& settings,
-    const std::vector<printing::PageRange>& page_ranges,
+    std::vector<printing::PageRange>* page_ranges,
     int* highest_rendered_page_number,
     double* scale_factor) {
   *highest_rendered_page_number = -1;
   *scale_factor = 1.0;
+  CHECK(page_ranges);
   base::win::ScopedHandle file(pdf_file);
 
   if (!g_pdf_lib.Get().IsValid())
     return false;
 
   // TODO(sanjeevr): Add a method to the PDF DLL that takes in a file handle
   // and a page range array. That way we don't need to read the entire PDF into
   // memory.
   DWORD length = ::GetFileSize(file, NULL);
   if (length == INVALID_FILE_SIZE)
     return false;
 
   std::vector<uint8> buffer;
   buffer.resize(length);
   DWORD bytes_read = 0;
   if (!ReadFile(pdf_file, &buffer.front(), length, &bytes_read, NULL) ||
       (bytes_read != length)) {
     return false;
   }
 
   int total_page_count = 0;
   if (!g_pdf_lib.Get().GetPDFDocInfo(&buffer.front(), buffer.size(),
                                      &total_page_count, NULL)) {
     return false;
   }
 
-  printing::Emf metafile;
-  metafile.InitToFile(metafile_path);
-  // 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(),
-                                          settings.area().right(),
-                                          settings.area().bottom());
-  gfx::ScaleDC(metafile.context(), *scale_factor);
+  // If no range supplied, do all pages.
+  if (page_ranges->empty()) {
+    printing::PageRange page_range_all;
+    page_range_all.from = 0;
+    page_range_all.to = total_page_count - 1;
+    page_ranges->push_back(page_range_all);
+  }
 
   bool ret = false;
   std::vector<printing::PageRange>::const_iterator iter;
-  for (iter = page_ranges.begin(); iter != page_ranges.end(); ++iter) {
+  for (iter = page_ranges->begin(); iter != page_ranges->end(); ++iter) {
     for (int page_number = iter->from; page_number <= iter->to; ++page_number) {
       if (page_number >= total_page_count)
         break;
+
+      printing::Emf metafile;
+      metafile.InitToFile(metafile_path.InsertBeforeExtensionASCII(
+          base::StringPrintf(".%d", page_number)));
+
+      // 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(),
+                                              settings.area().right(),
+                                              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);
       if (g_pdf_lib.Get().RenderPDFPageToDC(
               &buffer.front(), buffer.size(), page_number, metafile.context(),
               settings.dpi(), settings.dpi(), settings.area().x(),
               settings.area().y(), settings.area().width(),
               settings.area().height(), true, false, true, true,
               settings.autorotate())) {
         if (*highest_rendered_page_number < page_number)
           *highest_rendered_page_number = page_number;
         ret = true;
       }
       metafile.FinishPage();
+      metafile.FinishDocument();
     }
   }
-  metafile.FinishDocument();
   return ret;
 }
 #endif  // defined(OS_WIN)
 
 bool ChromeContentUtilityClient::RenderPDFPagesToPWGRaster(
     base::PlatformFile pdf_file,
     const printing::PdfRenderSettings& settings,
     const printing::PwgRasterSettings& bitmap_settings,
     base::PlatformFile bitmap_file) {
   bool autoupdate = true;
@@ skipping 325 matching lines @@
     NetworkingPrivateCrypto crypto;
     success = crypto.EncryptByteString(public_key, key_data, &ciphertext);
   }
 
   Send(new ChromeUtilityHostMsg_GotEncryptedWiFiCredentials(ciphertext,
                                                             success));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace chrome