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 174 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_RenderPDFToMetafile,
+                        OnRenderPDFToMetafile)
     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();
 }
 
+#if defined(OS_WIN)
+void ChromeContentUtilityClient::OnRenderPDFToMetafile(
+    base::PlatformFile pdf_transit,
+    const base::FilePath& metafile_path,
+    const printing::PdfRenderSettings& settings) {
+  base::PlatformFile pdf_file =
+      IPC::PlatformFileForTransitToPlatformFile(pdf_transit);
+  bool succeeded = false;
+  int highest_rendered_page_number = -1;
+  double scale_factor = 1.0;
+
+  if (!g_pdf_lib.Get().IsValid())
+    return;
+
+  DWORD length = ::GetFileSize(pdf_file, NULL);
+  if (length == INVALID_FILE_SIZE)
+    return;
+
+  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;
+  }
+
+  int total_page_count = 0;
+  if (!g_pdf_lib.Get().GetPDFDocInfo(&buffer.front(), buffer.size(),
+                                     &total_page_count, NULL)) {
+    return;
+  }
+
+  for (int i = 0; i < total_page_count; ++i) {
+    printing::Emf metafile;
+    metafile.InitToFile(
+        metafile_path.InsertBeforeExtensionASCII(base::StringPrintf(".%d", i)));
+    scale_factor = gfx::CalculatePageScale(
+        metafile.context(), settings.area().right(), settings.area().bottom());
+    gfx::ScaleDC(metafile.context(), scale_factor);
+    metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
+    if (g_pdf_lib.Get().RenderPDFPageToDC(
+          &buffer.front(), buffer.size(), i, 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 < i)
+        highest_rendered_page_number = i;
+    }
+    metafile.FinishPage();
+    metafile.FinishDocument();
+  }
+
+  if (highest_rendered_page_number >= 0) {
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
+        highest_rendered_page_number, scale_factor));

[Vitaly Buka (NO REVIEWS), 2014/05/14 03:51:18]

Actually with this approach we could send success message for every page, so
browser can start spooling early.

+  } else {
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
+  }
+  ReleaseProcessIfNeeded();
+}
+#endif  // defined(OS_WIN)
+
 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)) {
@@ skipping 34 matching lines @@
     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);

[Vitaly Buka (NO REVIEWS), 2014/05/13 23:54:33]

maybe just update this function to use file per page?
metafile_path.InsertBeforeExtensionASCII(base::StringPrintf(".%d", i)));

[scottmg, 2014/05/14 00:34:48]

At the moment, print_system_win.cc expects all pages to be in the same emf, so
that would need to be changed. (As it happens, it's only actually one at a time
despite the comment ;)
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/service/clo...
)

It would also need to understand the addition of .%d as now it expects the data
to show up that file rather than receiving the output.

I would also need to have an empty range mean "all pages" as PdfToEmfConverter
doesn't know how many pages are in the pdf until they're converted by the
utility.

Do you prefer those changes/does that sound right?

[Vitaly Buka (NO REVIEWS), 2014/05/14 03:51:18]

This sounds right. 
You can fix this or just TODO on me.

On 2014/05/14 00:34:48, scottmg wrote:

[scottmg, 2014/05/15 18:01:30]

OK, I tried to merge the messages, cloud print and converter code paths.

It now always inserts the %d for page number. The success message now passes
back a vector<PageRange> so that the file names can be correctly determined. I
also pass in IPC::PlatformFileForTransit as they were different before.

For now, I made it CHECK that only one page at a time is returned in the cloud
print case and added a TODO there, as it's been like that for a long time
anyway, and the calling code in print_system_win would need to be reorganized a
bit.

I also changed "Metafile" to "Metafiles" in the message names to make a it bit
more clear that multiple would be generated.

I didn't rebase, so 19->20 is the diffs.

   // 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 360 matching lines @@
     NetworkingPrivateCrypto crypto;
     success = crypto.EncryptByteString(public_key, key_data, &ciphertext);
   }
 
   Send(new ChromeUtilityHostMsg_GotEncryptedWiFiCredentials(ciphertext,
                                                             success));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace chrome