Printing on Windows via PDF

chrome/browser/printing/print_view_manager_base.cc

 // Copyright 2013 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/browser/printing/print_view_manager_base.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 26 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #endif
 
 #if defined(ENABLE_FULL_PRINTING)
 #include "chrome/browser/printing/print_error_dialog.h"
 #endif
 
 using base::TimeDelta;
 using content::BrowserThread;
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) && PRINTING_USE_EMF_METAFILE
 // Limits memory usage by raster to 64 MiB.
 const int kMaxRasterSizeInPixels = 16*1024*1024;
 #endif
 
 namespace printing {
 
 PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       number_pages_(0),
       printing_succeeded_(false),
       inside_inner_message_loop_(false),
       cookie_(0),
       queue_(g_browser_process->print_job_manager()->queue()) {
   DCHECK(queue_);
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if (defined(OS_POSIX) && !defined(OS_MACOSX)) || \
+    (defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE)
   expecting_first_page_ = true;
 #endif
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   printing_enabled_.Init(
       prefs::kPrintingEnabled,
       profile->GetPrefs(),
       base::Bind(&PrintViewManagerBase::UpdateScriptedPrintingBlocked,
                  base::Unretained(this)));
 }
@@ skipping 33 matching lines @@
   }
 }
 
 base::string16 PrintViewManagerBase::RenderSourceName() {
   base::string16 name(web_contents()->GetTitle());
   if (name.empty())
     name = l10n_util::GetStringUTF16(IDS_DEFAULT_PRINT_DOCUMENT_TITLE);
   return name;
 }
 
+#if 0 && defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE
+void PrintViewManagerBase::OnRenderPDFPagesToMetafileSucceeded(
+    const printing::Emf& metafile,
+    int highest_rendered_page_number,
+    double scale_factor) {
+  CHECK(false);
+}
+#endif  // OS_WIN && !PRINTING_USE_EMF_METAFILE
+
 void PrintViewManagerBase::OnDidGetPrintedPagesCount(int cookie,
                                                      int number_pages) {
   DCHECK_GT(cookie, 0);
   DCHECK_GT(number_pages, 0);
   number_pages_ = number_pages;
   OpportunisticallyCreatePrintJob(cookie);
 }
 
 void PrintViewManagerBase::OnDidGetDocumentCookie(int cookie) {
   cookie_ = cookie;
 }
 
 void PrintViewManagerBase::OnDidPrintPage(
     const PrintHostMsg_DidPrintPage_Params& params) {
   if (!OpportunisticallyCreatePrintJob(params.document_cookie))
     return;
 
   PrintedDocument* document = print_job_->document();
   if (!document || params.document_cookie != document->cookie()) {
     // Out of sync. It may happen since we are completely asynchronous. Old
     // spurious messages can be received if one of the processes is overloaded.
     return;
   }
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
+#if (defined(OS_WIN) && PRINTING_USE_EMF_METAFILE) || defined(OS_MACOSX)
   const bool metafile_must_be_valid = true;
-#elif defined(OS_POSIX)
+#elif defined(OS_POSIX) || (defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE)
   const bool metafile_must_be_valid = expecting_first_page_;
   expecting_first_page_ = false;
 #endif
 
   base::SharedMemory shared_buf(params.metafile_data_handle, true);
   if (metafile_must_be_valid) {
     if (!shared_buf.Map(params.data_size)) {
       NOTREACHED() << "couldn't map";
       web_contents()->Stop();
       return;
     }
   }
 
   scoped_ptr<NativeMetafile> metafile(new NativeMetafile);
   if (metafile_must_be_valid) {
     if (!metafile->InitFromData(shared_buf.memory(), params.data_size)) {
       NOTREACHED() << "Invalid metafile header";
       web_contents()->Stop();
       return;
     }
   }
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) && PRINTING_USE_EMF_METAFILE
   bool big_emf = (params.data_size && params.data_size >= kMetafileMaxSize);
   int raster_size = std::min(params.page_size.GetArea(),
                              kMaxRasterSizeInPixels);
   if (big_emf) {
     scoped_ptr<NativeMetafile> raster_metafile(
         metafile->RasterizeMetafile(raster_size));
     if (raster_metafile.get()) {
       metafile.swap(raster_metafile);
     } else if (big_emf) {
       // Don't fall back to emf here.
       NOTREACHED() << "size:" << params.data_size;
       TerminatePrintJob(true);
       web_contents()->Stop();
       return;
     }
   }
+#elif 0 && defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE
+  ConvertPDFToEMF(metafile.Pass());
 #endif
 
   // Update the rendered document. It will send notifications to the listener.
   document->SetPage(params.page_number,
                     metafile.release(),
                     params.actual_shrink,
                     params.page_size,
                     params.content_area);
 
   ShouldQuitFromInnerMessageLoop();
@@ skipping 196 matching lines @@
   if (print_job_.get() &&
       print_job_->document() &&
       !print_job_->document()->IsComplete()) {
     DCHECK(!result);
     // That failed.
     TerminatePrintJob(true);
   } else {
     // DO NOT wait for the job to finish.
     ReleasePrintJob();
   }
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if (defined(OS_POSIX) && !defined(OS_MACOSX)) || \
+    (defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE)
   expecting_first_page_ = true;
 #endif
 }
 
 void PrintViewManagerBase::PrintingDone(bool success) {
   if (!print_job_.get())
     return;
   Send(new PrintMsg_PrintingDone(routing_id(), success));
 }
 
@@ skipping 122 matching lines @@
 
   scoped_refptr<printing::PrinterQuery> printer_query;
   printer_query = queue_->PopPrinterQuery(cookie);
   if (!printer_query)
     return;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrinterQuery::StopWorker, printer_query.get()));
 }
 
+#if 0 && defined(OS_WIN) && !PRINTING_USE_EMF_METAFILE
+void PrintViewManagerBase::ConvertPDFToEMF(
+    scoped_ptr<NativeMetafile> metafile) {
+  scoped_ptr<ServiceUtilityProcessHost> utility_host(

[Vitaly Buka (NO REVIEWS), 2014/04/24 22:47:58]

ServiceUtilityProcessHost is for use in Service process only.

Take a look at PwgUtilityProcessHostClient. you can clone for EMF
or move to separate file and extend with ConvertToPwg, ConvertToEMF

[scottmg, 2014/04/25 20:47:18]

Thanks for the pointer, that seems to be mostly working.

+      new ServiceUtilityProcessHost(this, client_message_loop_proxy));
+  if (utility_host->StartRenderPDFPagesToMetafile(
+          pdf_path,
+          printing::PdfRenderSettings(render_area, render_dpi, false),
+          page_ranges)) {

[Vitaly Buka (NO REVIEWS), 2014/04/24 22:47:58]

Message ChromeUtilityMsg_RenderPDFPagesToMetafile should be fixed, to use
PlatformFileForTransit. I'll do that right now. it should not significant
conflicts for you.

[Vitaly Buka (NO REVIEWS), 2014/04/25 05:25:48]

It's going to be harder then I thought, Win32 metafile works only with file
path, not with file handles.
So I will not change right now, to avoid introducing new source of regressions
here.

On 2014/04/24 22:47:58, Vitaly Buka wrote:

[scottmg, 2014/04/25 20:47:18]

I gave it a shot, basically using GetEnhMetaFileBits and adding a
PlatformFileForTransit version of the message in addition to the path one.

+    // The object will self-destruct when the child process dies.
+    utility_host.release();
+  }
+}
+#endif  // OS_WIN && !PRINTING_USE_EMF_METAFILE
+
 }  // namespace printing