Use file handles to interact with utility process.

chrome/service/cloud_print/print_system_win.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/service/cloud_print/print_system.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/object_watcher.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_hdc.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/cloud_print/cloud_print_cdd_conversion.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/service/cloud_print/cdd_conversion_win.h"
 #include "chrome/service/service_process.h"
 #include "chrome/service/service_utility_process_host.h"
 #include "printing/backend/win_helper.h"
 #include "printing/emf_win.h"
 #include "printing/page_range.h"
+#include "printing/pdf_render_settings.h"
 #include "printing/printing_utils.h"
+#include "ui/gfx/geometry/rect.h"
 
 namespace cloud_print {
 
 namespace {
 
 class PrintSystemWatcherWin : public base::win::ObjectWatcher::Delegate {
  public:
   PrintSystemWatcherWin()
       : delegate_(NULL),
         did_signal_(false) {
@@ skipping 201 matching lines @@
 
  protected:
   virtual ~JobSpoolerWin() {}
 
  private:
   // We use a Core class because we want a separate RefCountedThreadSafe
   // implementation for ServiceUtilityProcessHost::Client.
   class Core : public ServiceUtilityProcessHost::Client,
                public base::win::ObjectWatcher::Delegate {
    public:
-    Core()
-        : last_page_printed_(-1),
-          job_id_(-1),
-          delegate_(NULL),
-          saved_dc_(0) {
-    }
+    Core() : job_id_(-1), delegate_(NULL), saved_dc_(0) {}
 
     ~Core() {}
 
     bool Spool(const std::string& print_ticket,
                const std::string& print_ticket_mime_type,
                const base::FilePath& print_data_file_path,
                const std::string& print_data_mime_type,
                const std::string& printer_name,
                const std::string& job_title,
                JobSpooler::Delegate* delegate) {
       if (delegate_) {
         // We are already in the process of printing.
         NOTREACHED();
         return false;
       }
       base::string16 printer_wide = base::UTF8ToWide(printer_name);
-      last_page_printed_ = -1;
       // We only support PDF and XPS documents for now.
       if (print_data_mime_type == kContentTypePDF) {
         scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode;
         if (print_ticket_mime_type == kContentTypeJSON) {
           dev_mode = CjtToDevMode(printer_wide, print_ticket);
         } else {
           DCHECK(print_ticket_mime_type == kContentTypeXML);
           dev_mode = printing::XpsTicketToDevMode(printer_wide, print_ticket);
         }
 
@@ skipping 14 matching lines @@
         DCHECK(printing::SimplifyDocumentTitle(doc_name) == doc_name);
         di.lpszDocName = doc_name.c_str();
         job_id_ = StartDoc(dc, &di);
         if (job_id_ <= 0)
           return false;
 
         printer_dc_.Set(dc);
         saved_dc_ = SaveDC(printer_dc_.Get());
         print_data_file_path_ = print_data_file_path;
         delegate_ = delegate;
-        RenderNextPDFPages();
+        RenderPDFPages();
       } else if (print_data_mime_type == kContentTypeXPS) {
         DCHECK(print_ticket_mime_type == kContentTypeXML);
         bool ret = PrintXPSDocument(printer_name,
                                     job_title,
                                     print_data_file_path,
                                     print_ticket);
         if (ret)
           delegate_ = delegate;
         return ret;
       } else {
@@ skipping 12 matching lines @@
       int offset_x = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETX);
       int offset_y = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETY);
       XFORM xform = {0};
       xform.eDx = static_cast<float>(-offset_x);
       xform.eDy = static_cast<float>(-offset_y);
       xform.eM11 = xform.eM22 = 1.0 / scale_factor;
       SetWorldTransform(printer_dc_.Get(), &xform);
     }
 
     // ServiceUtilityProcessHost::Client implementation.
-    virtual void OnRenderPDFPagesToMetafileSucceeded(
-        const printing::MetafilePlayer& metafile,
-        int highest_rendered_page_number,
-        double scale_factor) OVERRIDE {
+    virtual void OnRenderPDFPagesToMetafilePageDone(
+        double scale_factor,
+        const printing::MetafilePlayer& emf) OVERRIDE {
       PreparePageDCForPrinting(printer_dc_.Get(), scale_factor);
-      metafile.SafePlayback(printer_dc_.Get());
-      bool done_printing = (highest_rendered_page_number !=
-          last_page_printed_ + kPageCountPerBatch);
-      last_page_printed_ = highest_rendered_page_number;
-      if (done_printing)
-        PrintJobDone();
-      else
-        RenderNextPDFPages();
+      emf.SafePlayback(printer_dc_.Get());
     }
 
+    // ServiceUtilityProcessHost::Client implementation.
+    virtual void OnRenderPDFPagesToMetafileDone(bool success) OVERRIDE {
+      PrintJobDone(success);
+    }
+
+    virtual void OnChildDied() OVERRIDE { PrintJobDone(false); }
+
     // base::win::ObjectWatcher::Delegate implementation.
     virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
       DCHECK(xps_print_job_);
       DCHECK(object == job_progress_event_.Get());
       ResetEvent(job_progress_event_.Get());
       if (!delegate_)
         return;
       XPS_JOB_STATUS job_status = {0};
       xps_print_job_->GetJobStatus(&job_status);
       if ((job_status.completion == XPS_JOB_CANCELLED) ||
           (job_status.completion == XPS_JOB_FAILED)) {
         delegate_->OnJobSpoolFailed();
       } else if (job_status.jobId ||
                   (job_status.completion == XPS_JOB_COMPLETED)) {
         // Note: In the case of the XPS document being printed to the
         // Microsoft XPS Document Writer, it seems to skip spooling the job
         // and goes to the completed state without ever assigning a job id.
         delegate_->OnJobSpoolSucceeded(job_status.jobId);
       } else {
         job_progress_watcher_.StopWatching();
         job_progress_watcher_.StartWatching(job_progress_event_.Get(), this);
       }
     }
 
-    virtual void OnRenderPDFPagesToMetafileFailed() OVERRIDE {
-      PrintJobDone();
-    }
-
-    virtual void OnChildDied() OVERRIDE {
-      PrintJobDone();
-    }
-
    private:
     // Helper class to allow PrintXPSDocument() to have multiple exits.
     class PrintJobCanceler {
      public:
       explicit PrintJobCanceler(
           base::win::ScopedComPtr<IXpsPrintJob>* job_ptr)
           : job_ptr_(job_ptr) {
       }
       ~PrintJobCanceler() {
         if (job_ptr_ && *job_ptr_) {
           (*job_ptr_)->Cancel();
           job_ptr_->Release();
         }
       }
 
       void reset() { job_ptr_ = NULL; }
 
      private:
       base::win::ScopedComPtr<IXpsPrintJob>* job_ptr_;
 
       DISALLOW_COPY_AND_ASSIGN(PrintJobCanceler);
     };
 
-    void PrintJobDone() {
+    void PrintJobDone(bool success) {
       // If there is no delegate, then there is nothing pending to process.
       if (!delegate_)
         return;
       RestoreDC(printer_dc_.Get(), saved_dc_);
       EndDoc(printer_dc_.Get());
-      if (-1 == last_page_printed_) {
+      if (success) {
+        delegate_->OnJobSpoolSucceeded(job_id_);
+      } else {
         delegate_->OnJobSpoolFailed();
-      } else {
-        delegate_->OnJobSpoolSucceeded(job_id_);
       }
       delegate_ = NULL;
     }
 
-    void RenderNextPDFPages() {
-      printing::PageRange range;
-      // Render 10 pages at a time.
-      range.from = last_page_printed_ + 1;
-      range.to = last_page_printed_ + kPageCountPerBatch;
-      std::vector<printing::PageRange> page_ranges;
-      page_ranges.push_back(range);
-
+    void RenderPDFPages() {
       int printer_dpi = ::GetDeviceCaps(printer_dc_.Get(), LOGPIXELSX);
       int dc_width = GetDeviceCaps(printer_dc_.Get(), PHYSICALWIDTH);
       int dc_height = GetDeviceCaps(printer_dc_.Get(), PHYSICALHEIGHT);
       gfx::Rect render_area(0, 0, dc_width, dc_height);
       g_service_process->io_thread()->message_loop_proxy()->PostTask(
           FROM_HERE,
-          base::Bind(&JobSpoolerWin::Core::RenderPDFPagesInSandbox, this,
-                      print_data_file_path_, render_area, printer_dpi,
-                      page_ranges, base::MessageLoopProxy::current()));
+          base::Bind(&JobSpoolerWin::Core::RenderPDFPagesInSandbox,
+                     this,
+                     print_data_file_path_,
+                     render_area,
+                     printer_dpi,
+                     base::MessageLoopProxy::current()));
     }
 
     // Called on the service process IO thread.
-    void RenderPDFPagesInSandbox(
-        const base::FilePath& pdf_path, const gfx::Rect& render_area,
-        int render_dpi, const std::vector<printing::PageRange>& page_ranges,
-        const scoped_refptr<base::MessageLoopProxy>&
-            client_message_loop_proxy) {
+    void RenderPDFPagesInSandbox(const base::FilePath& pdf_path,
+                                 const gfx::Rect& render_area,
+                                 int render_dpi,
+                                 const scoped_refptr<base::MessageLoopProxy>&
+                                     client_message_loop_proxy) {
       DCHECK(g_service_process->io_thread()->message_loop_proxy()->
           BelongsToCurrentThread());
       scoped_ptr<ServiceUtilityProcessHost> utility_host(
           new ServiceUtilityProcessHost(this, client_message_loop_proxy));
       // TODO(gene): For now we disabling autorotation for CloudPrinting.
       // Landscape/Portrait setting is passed in the print ticket and
       // server is generating portrait PDF always.
       // We should enable autorotation once server will be able to generate
       // PDF that matches paper size and orientation.
       if (utility_host->StartRenderPDFPagesToMetafile(
               pdf_path,
-              printing::PdfRenderSettings(render_area, render_dpi, false),
-              page_ranges)) {
+              printing::PdfRenderSettings(render_area, render_dpi, false))) {
         // The object will self-destruct when the child process dies.
         utility_host.release();
+      } else {
+        client_message_loop_proxy->PostTask(
+            FROM_HERE, base::Bind(&Core::PrintJobDone, this, false));
       }
     }
 
     bool PrintXPSDocument(const std::string& printer_name,
                           const std::string& job_title,
                           const base::FilePath& print_data_file_path,
                           const std::string& print_ticket) {
       if (!printing::XPSPrintModule::Init())
         return false;
 
@@ skipping 30 matching lines @@
         return false;
       DCHECK_EQ(document_data.length(), doc_bytes_written);
       if (FAILED(doc_stream->Close()))
         return false;
 
       job_progress_watcher_.StartWatching(job_progress_event_.Get(), this);
       job_canceler.reset();
       return true;
     }
 
-    // Some Cairo-generated PDFs from Chrome OS result in huge metafiles.
-    // So the PageCountPerBatch is set to 1 for now.
-    // TODO(sanjeevr): Figure out a smarter way to determine the pages per
-    // batch. Filed a bug to track this at
-    // http://code.google.com/p/chromium/issues/detail?id=57350.
-    static const int kPageCountPerBatch = 1;
-
-    int last_page_printed_;
     PlatformJobId job_id_;
     PrintSystem::JobSpooler::Delegate* delegate_;
     int saved_dc_;
     base::win::ScopedCreateDC printer_dc_;
     base::FilePath print_data_file_path_;
     base::win::ScopedHandle job_progress_event_;
     base::win::ObjectWatcher job_progress_watcher_;
     base::win::ScopedComPtr<IXpsPrintJob> xps_print_job_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
@@ skipping 310 matching lines @@
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print