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