Use file handles to interact with utility process.

chrome/browser/printing/print_job.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/browser/printing/print_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/printing/print_job_worker.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "printing/printed_document.h"
 #include "printing/printed_page.h"
 
+#if defined(OS_WIN)
+#include "chrome/browser/printing/pdf_to_emf_converter.h"
+#include "printing/pdf_render_settings.h"
+#endif
+
 using base::TimeDelta;
 
 namespace {
 
 // Helper function to ensure |owner| is valid until at least |callback| returns.
 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
                      const base::Closure& callback) {
   callback.Run();
 }
 
 }  // namespace
 
 namespace printing {
 
 PrintJob::PrintJob()
     : source_(NULL),
       worker_(),
       settings_(),
       is_job_pending_(false),
       is_canceling_(false),
+#if defined(OS_WIN)
+      pdf_to_emf_page_count_(0),
+      pdf_to_emf_current_page_(0),
+#endif
       quit_factory_(this) {
   // This is normally a UI message loop, but in unit tests, the message loop is
   // of the 'default' type.
   DCHECK(base::MessageLoopForUI::IsCurrent() ||
          base::MessageLoop::current()->type() ==
              base::MessageLoop::TYPE_DEFAULT);
 }
 
 PrintJob::~PrintJob() {
   // The job should be finished (or at least canceled) when it is destroyed.
@@ skipping 157 matching lines @@
 }
 
 bool PrintJob::is_job_pending() const {
   return is_job_pending_;
 }
 
 PrintedDocument* PrintJob::document() const {
   return document_.get();
 }
 
+#if defined(OS_WIN)
+void PrintJob::ConvertPdfToEmf(
+    const scoped_refptr<base::RefCountedMemory>& bytes,
+    gfx::Size page_size,
+    gfx::Rect content_area) {

[Lei Zhang, 2014/09/15 21:49:53]

Can you DCHECK here and in the callbacks to make sure you are on the right
thread.

[Vitaly Buka (NO REVIEWS), 2014/09/15 22:33:50]

Done.

+  DCHECK(!pdf_to_emf_converter_.get());
+  pdf_to_emf_converter_ = PdfToEmfConverter::CreateDefault();
+  const int kPrinterDpi = settings().dpi();
+  pdf_to_emf_page_size_ = page_size;

[Lei Zhang, 2014/09/15 21:49:53]

This is set once here for PDF file. Is the PDF file guaranteeded to have all
pages be the same size at this point? Arbitrary PDFs can have pages with
different page sizes.

Is the PDF only 1 page when called from PrintViewManagerBase::OnDidPrintPage()
so it doesn't matter in that case?

[Vitaly Buka (NO REVIEWS), 2014/09/15 22:33:50]

That's looks incorrect. 
But I don't change behaivour in this patch. 
Maybe it was regressed when we switched from EMF to PDF for renderer IPC

I'll file but to investigate.
https://code.google.com/p/chromium/issues/detail?id=414477

On 2014/09/15 21:49:53, Lei Zhang wrote:

+  pdf_to_emf_content_area_ = content_area;
+  pdf_to_emf_converter_->Start(
+      bytes,
+      printing::PdfRenderSettings(content_area, kPrinterDpi, true),
+      base::Bind(&PrintJob::OnPdfLoaded, this));
+}
+
+void PrintJob::OnPdfPageConvertedToEmf(int page_number,
+                                       double scale_factor,
+                                       scoped_ptr<MetafilePlayer> emf) {
+  DCHECK(pdf_to_emf_converter_);
+  if (!document_.get() || !emf)
+    return OnPdfLoaded(false);
+
+  // Update the rendered document. It will send notifications to the listener.
+  document_->SetPage(pdf_to_emf_current_page_++,
+                     emf.Pass(),
+                     scale_factor,
+                     pdf_to_emf_page_size_,
+                     pdf_to_emf_content_area_);
+
+  if (pdf_to_emf_current_page_ < pdf_to_emf_page_count_)

[Lei Zhang, 2014/09/15 21:49:53]

nit: wrap inner block in braces.

[Vitaly Buka (NO REVIEWS), 2014/09/15 22:33:50]

Done.

[Vitaly Buka (NO REVIEWS), 2014/09/15 22:33:50]

Done.

+    pdf_to_emf_converter_->GetPage(
+        pdf_to_emf_current_page_,
+        base::Bind(&PrintJob::OnPdfPageConvertedToEmf, this));
+}
+
+void PrintJob::OnPdfLoaded(int page_count) {
+  if (page_count <= 0) {
+    pdf_to_emf_converter_.reset();
+    Cancel();
+    return;
+  }
+  pdf_to_emf_page_count_ = page_count;
+  pdf_to_emf_current_page_ = 0;
+
+  pdf_to_emf_converter_->GetPage(
+      pdf_to_emf_current_page_,
+      base::Bind(&PrintJob::OnPdfPageConvertedToEmf, this));
+}
+#endif  // OS_WIN
+
 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (document_.get() == new_document)
     return;
 
   document_ = new_document;
 
   if (document_.get()) {
     settings_ = document_->settings();
   }
 
@@ skipping 119 matching lines @@
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing