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 347 matching lines @@
   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,
                         OnRenderPDFPagesToMetafile)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafileHandles,
+                        OnRenderPDFPagesToMetafileHandles)
     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)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_PatchFileBsdiff,
@@ skipping 205 matching lines @@
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
         highest_rendered_page_number, scale_factor));
   }
 #endif  // defined(OS_WIN)
   if (!succeeded) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
   }
   ReleaseProcessIfNeeded();
 }
 
+void ChromeContentUtilityClient::OnRenderPDFPagesToMetafileHandles(
+    IPC::PlatformFileForTransit pdf_transit,
+    IPC::PlatformFileForTransit metafile_transit,
+    const printing::PdfRenderSettings& settings,
+    const std::vector<printing::PageRange>& page_ranges) {
+  bool succeeded = false;
+#if defined(OS_WIN)
+  int highest_rendered_page_number = 0;
+  double scale_factor = 1.0;
+  base::PlatformFile pdf =
+      IPC::PlatformFileForTransitToPlatformFile(pdf_transit);
+  base::PlatformFile metafile =
+      IPC::PlatformFileForTransitToPlatformFile(metafile_transit);
+  succeeded = RenderPDFToWinMetafileHandles(pdf,
+                                            metafile,
+                                            settings,
+                                            page_ranges,
+                                            &highest_rendered_page_number,
+                                            &scale_factor);
+  if (succeeded) {
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
+        highest_rendered_page_number, scale_factor));
+  }
+#endif  // defined(OS_WIN)
+  if (!succeeded) {
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
+  }
+  ReleaseProcessIfNeeded();
+}
+
 void ChromeContentUtilityClient::OnRenderPDFPagesToPWGRaster(
     IPC::PlatformFileForTransit pdf_transit,
     const printing::PdfRenderSettings& settings,
     const printing::PwgRasterSettings& bitmap_settings,
     IPC::PlatformFileForTransit bitmap_transit) {
   base::PlatformFile pdf =
       IPC::PlatformFileForTransitToPlatformFile(pdf_transit);
   base::PlatformFile bitmap =
       IPC::PlatformFileForTransitToPlatformFile(bitmap_transit);
   if (RenderPDFPagesToPWGRaster(pdf, settings, bitmap_settings, bitmap)) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Succeeded());
   } else {
     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,
     int* highest_rendered_page_number,
     double* scale_factor) {
+  base::File metafile;
+  metafile.Initialize(metafile_path,
+                      base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_APPEND);
+  return RenderPDFToWinMetafileHandles(pdf_file,
+                                       metafile.GetPlatformFile(),
+                                       settings,
+                                       page_ranges,
+                                       highest_rendered_page_number,
+                                       scale_factor);
+}
+
+bool ChromeContentUtilityClient::RenderPDFToWinMetafileHandles(
+    base::PlatformFile pdf_file,
+    base::PlatformFile metafile_file,
+    const printing::PdfRenderSettings& settings,
+    const std::vector<printing::PageRange>& page_ranges,
+    int* highest_rendered_page_number,
+    double* scale_factor) {
   *highest_rendered_page_number = -1;
   *scale_factor = 1.0;
   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);
+  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(),
                                           settings.area().right(),
                                           settings.area().bottom());
@@ skipping 15 matching lines @@
               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();
+
+  uint32 final_size = metafile.GetDataSize();
+  scoped_ptr<char[]> final_buffer(new char[final_size]);
+  CHECK(metafile.GetData(final_buffer.get(), final_size));
+  CHECK_EQ(static_cast<int>(final_size),

[Vitaly Buka (NO REVIEWS), 2014/04/25 22:35:24]

This could be huge, metafile keeps images uncompressed.
browser<->renderer uses metafile per page, and there is bugs when it can't
allocate +200MB of shared memory for page.
You can just write stream size+page_data,size+page_data,size+page_data.

[scottmg, 2014/04/25 23:07:18]

Sorry, I'm not sure what you mean here. You mean converting an EMF one page at a
time here, and then merging them somehow? The only EMF data retrieval function
seems to be for the whole file.

I'm looking at a spec here http://www.schnarff.com/file-formats/emf/[MS-EMF].pdf
it looks a bit involved to merge multiple EMF (or would at least need some
record parsing it looks like).

Or do you mean it needs to do the kMetafileMaxSize path and use
RasterizeMetafile instead?

[Vitaly Buka (NO REVIEWS), 2014/04/28 06:47:33]

It's not about rasterize.

You don't need to try to create single readable metafile like in spec.
Just concatenate them, and split on other side spooling to printers:

for (int page_number = iter->from; page_number <= iter->to; ++page_number) {
  printing::Emf metafile;
  metafile.Init();
  
  ... print one page ...
  
  base::WritePlatformFile(size);
  base::WritePlatformFile(metafile_file, 0, final_buffer.get(), final_size));
}


Ideal approach is to start Utility process in batch mode, open PDF doc once
and then request each page with separate IPC message. So we will have only one
page on disk in time, and we would able to spool the first page sooner.

I recently noticed that the same in cloud print implemented even without batch
mode. It has parameter page_range, but it always single page. Without batch mode
it just re-opens PDF for each page, inefficient.

[Vitaly Buka (NO REVIEWS), 2014/04/28 06:49:07]

base::WritePlatformFile -> base::WritePlatformFileAtCurrentPos to append

On 2014/04/28 06:47:33, Vitaly Buka wrote:

+           base::WritePlatformFile(
+               metafile_file, 0, final_buffer.get(), final_size));
   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 327 matching lines @@
     NetworkingPrivateCrypto crypto;
     success = crypto.EncryptByteString(public_key, key_data, &ciphertext);
   }
 
   Send(new ChromeUtilityHostMsg_GotEncryptedWiFiCredentials(ciphertext,
                                                             success));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace chrome