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();
 }
 
@@ skipping 177 matching lines @@
 }
 
 bool PrintJob::is_job_pending() const {
   return is_job_pending_;
 }
 
 PrintedDocument* PrintJob::document() const {
   return document_.get();
 }
 
+#if defined(OS_WIN)
+
+class PrintJob::PdfToEmfState {
+ public:
+  PdfToEmfState(const gfx::Size& page_size, const gfx::Rect& content_area)
+      : page_count_(0),
+        current_page_(0),
+        pages_in_progress_(0),
+        page_size_(page_size),
+        content_area_(content_area),
+        converter_(PdfToEmfConverter::CreateDefault()) {}
+
+  void Start(const scoped_refptr<base::RefCountedMemory>& data,
+             const PdfRenderSettings& conversion_settings,
+             const PdfToEmfConverter::StartCallback& start_callback) {
+    converter_->Start(data, conversion_settings, start_callback);
+  }
+
+  void GetMorePages(
+      const PdfToEmfConverter::GetPageCallback& get_page_callback) {
+    const int kMaxNumberOfTempFilesPerDocument = 3;
+    while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
+           current_page_ < page_count_) {
+      ++pages_in_progress_;
+      converter_->GetPage(current_page_++, get_page_callback);
+    }
+  }
+
+  void OnPageProcessed(
+      const PdfToEmfConverter::GetPageCallback& get_page_callback) {
+    --pages_in_progress_;
+    GetMorePages(get_page_callback);
+    // Release converter if we don't need this any more.
+    if (!pages_in_progress_ && current_page_ >= page_count_)
+      converter_.reset();
+  }
+
+  void set_page_count(int page_count) { page_count_ = page_count; }
+  gfx::Size page_size() const { return page_size_; }
+  gfx::Rect content_area() const { return content_area_; }
+
+ private:
+  int page_count_;
+  int current_page_;
+  int pages_in_progress_;
+  gfx::Size page_size_;
+  gfx::Rect content_area_;
+  scoped_ptr<PdfToEmfConverter> converter_;
+};
+
+void PrintJob::StartPdfToEmfConversion(
+    const scoped_refptr<base::RefCountedMemory>& bytes,
+    const gfx::Size& page_size,
+    const gfx::Rect& content_area) {
+  DCHECK(!ptd_to_emf_state_.get());
+  ptd_to_emf_state_.reset(new PdfToEmfState(page_size, content_area));
+  const int kPrinterDpi = settings().dpi();
+  ptd_to_emf_state_->Start(
+      bytes,
+      printing::PdfRenderSettings(content_area, kPrinterDpi, true),
+      base::Bind(&PrintJob::OnPdfToEmfStarted, this));
+}
+
+void PrintJob::OnPdfToEmfStarted(int page_count) {
+  if (page_count <= 0) {
+    ptd_to_emf_state_.reset();
+    Cancel();
+    return;
+  }
+  ptd_to_emf_state_->set_page_count(page_count);
+  ptd_to_emf_state_->GetMorePages(
+      base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
+}
+
+void PrintJob::OnPdfToEmfPageConverted(int page_number,
+                                       double scale_factor,
+                                       scoped_ptr<MetafilePlayer> emf) {
+  DCHECK(ptd_to_emf_state_);
+  if (!document_.get() || !emf) {
+    ptd_to_emf_state_.reset();
+    Cancel();
+    return;
+  }
+
+  // Update the rendered document. It will send notifications to the listener.
+  document_->SetPage(page_number,
+                     emf.Pass(),
+                     scale_factor,
+                     ptd_to_emf_state_->page_size(),
+                     ptd_to_emf_state_->content_area());
+
+  ptd_to_emf_state_->GetMorePages(
+      base::Bind(&PrintJob::OnPdfToEmfPageConverted, 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 18 matching lines @@
       break;
     }
     case JobEventDetails::USER_INIT_DONE:
     case JobEventDetails::DEFAULT_INIT_DONE:
     case JobEventDetails::USER_INIT_CANCELED: {
       DCHECK_EQ(event_details.document(), document_.get());
       break;
     }
     case JobEventDetails::NEW_DOC:
     case JobEventDetails::NEW_PAGE:
-    case JobEventDetails::PAGE_DONE:
     case JobEventDetails::JOB_DONE:
     case JobEventDetails::ALL_PAGES_REQUESTED: {
       // Don't care.
       break;
     }
     case JobEventDetails::DOC_DONE: {
       // This will call Stop() and broadcast a JOB_DONE message.
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&PrintJob::OnDocumentDone, this));
       break;
     }
+    case JobEventDetails::PAGE_DONE:
+#if defined(OS_WIN)
+      ptd_to_emf_state_->OnPageProcessed(
+          base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
+#endif  // OS_WIN
+      break;
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void PrintJob::OnDocumentDone() {
   // Be sure to live long enough. The instance could be destroyed by the
   // JOB_DONE broadcast.
@@ skipping 69 matching lines @@
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing