Added support to the Windows cloud print proxy to print XPS documents directl...

chrome/service/cloud_print/print_system_win.cc

 // Copyright (c) 2010 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 <objidl.h>
 #include <winspool.h>
+#if defined(_WIN32_WINNT)
+#undef _WIN32_WINNT
+#endif  // defined(_WIN32_WINNT)
+#define _WIN32_WINNT _WIN32_WINNT_WIN7
+#include <xpsprint.h>
 
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/scoped_ptr.h"
 #include "base/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/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/service_process.h"
 #include "chrome/service/service_utility_process_host.h"
 #include "grit/generated_resources.h"
@@ skipping 338 matching lines @@
                        const std::vector<std::string>& tags,
                        JobSpooler::Delegate* delegate) {
       // TODO(gene): add tags handling.
       return core_->Spool(print_ticket, print_data_file_path,
                           print_data_mime_type, printer_name, job_title,
                           delegate);
     }
    private:
     // We use a Core class because we want a separate RefCountedThreadSafe
     // implementation for ServiceUtilityProcessHost::Client.
-    class Core : public 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) {
+          : last_page_printed_(-1),
+            job_id_(-1),
+            delegate_(NULL),
+            saved_dc_(0),
+            should_couninit_(false) {
       }
       ~Core() {
       }
       bool Spool(const std::string& print_ticket,
                  const 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;
         }
         last_page_printed_ = -1;
-        // We only support PDFs for now.
-        if (print_data_mime_type != "application/pdf") {
+        // We only support PDF and XPS documents for now.
+        if (print_data_mime_type == "application/pdf") {
+          DevMode pt_dev_mode;
+          HRESULT hr = PrintTicketToDevMode(printer_name, print_ticket,
+                                            &pt_dev_mode);
+          if (FAILED(hr)) {
+            NOTREACHED();
+            return false;
+          }
+
+          HDC dc = CreateDC(L"WINSPOOL", UTF8ToWide(printer_name).c_str(),
+                            NULL, pt_dev_mode.dm_);
+          if (!dc) {
+            NOTREACHED();
+            return false;
+          }
+          hr = E_FAIL;
+          DOCINFO di = {0};
+          di.cbSize = sizeof(DOCINFO);
+          std::wstring doc_name = UTF8ToWide(job_title);
+          di.lpszDocName = doc_name.c_str();
+          job_id_ = StartDoc(dc, &di);
+          if (job_id_ <= 0)
+            return false;
+
+          printer_dc_.Set(dc);
+          int printer_dpi = ::GetDeviceCaps(printer_dc_.Get(), LOGPIXELSX);
+          saved_dc_ = SaveDC(printer_dc_.Get());
+          SetGraphicsMode(printer_dc_.Get(), GM_ADVANCED);
+          XFORM xform = {0};
+          xform.eM11 = xform.eM22 = static_cast<float>(printer_dpi) /
+              static_cast<float>(GetDeviceCaps(GetDC(NULL), LOGPIXELSX));
+          ModifyWorldTransform(printer_dc_.Get(), &xform, MWT_LEFTMULTIPLY);
+          print_data_file_path_ = print_data_file_path;
+          delegate_ = delegate;
+          RenderNextPDFPages();
+        } else if (print_data_mime_type == "application/vnd.ms-xpsdocument") {
+          bool ret = PrintXPSDocument(printer_name,
+                                      job_title,
+                                      print_data_file_path,
+                                      print_ticket);
+          if (ret)
+            delegate_ = delegate;
+          return ret;
+        } else {
           NOTREACHED();
           return false;
         }
-
-        DevMode pt_dev_mode;
-        HRESULT hr = PrintTicketToDevMode(printer_name, print_ticket,
-                                          &pt_dev_mode);
-        if (FAILED(hr)) {
-          NOTREACHED();
-          return false;
-        }
-
-        HDC dc = CreateDC(L"WINSPOOL", UTF8ToWide(printer_name).c_str(),
-                          NULL, pt_dev_mode.dm_);
-        if (!dc) {
-          NOTREACHED();
-          return false;
-        }
-        hr = E_FAIL;
-        DOCINFO di = {0};
-        di.cbSize = sizeof(DOCINFO);
-        std::wstring doc_name = UTF8ToWide(job_title);
-        di.lpszDocName = doc_name.c_str();
-        job_id_ = StartDoc(dc, &di);
-        if (job_id_ <= 0)
-          return false;
-
-        printer_dc_.Set(dc);
-
-        int printer_dpi = ::GetDeviceCaps(printer_dc_.Get(), LOGPIXELSX);
-        saved_dc_ = SaveDC(printer_dc_.Get());
-        SetGraphicsMode(printer_dc_.Get(), GM_ADVANCED);
-        XFORM xform = {0};
-        xform.eM11 = xform.eM22 = static_cast<float>(printer_dpi) /
-            static_cast<float>(GetDeviceCaps(GetDC(NULL), LOGPIXELSX));
-        ModifyWorldTransform(printer_dc_.Get(), &xform, MWT_LEFTMULTIPLY);
-        print_data_file_path_ = print_data_file_path;
-        delegate_ = delegate;
-        RenderNextPDFPages();
         return true;
       }
 
       // ServiceUtilityProcessHost::Client implementation.
       virtual void OnRenderPDFPagesToMetafileSucceeded(
           const printing::NativeMetafile& metafile,
           int highest_rendered_page_number) {
         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();
       }
+
+      // base::win::ObjectWatcher::Delegate inplementation.
+      virtual void OnObjectSignaled(HANDLE object) {
+        DCHECK(xps_print_job_);
+        if (!delegate_)
+          return;
+        XPS_JOB_STATUS job_status = {0};
+        xps_print_job_->GetJobStatus(&job_status);
+        bool done = false;
+        if ((job_status.completion == XPS_JOB_CANCELLED) ||
+            (job_status.completion == XPS_JOB_FAILED)) {
+          delegate_->OnJobSpoolFailed();
+          done = true;
+        } else if (job_status.jobId) {
+          delegate_->OnJobSpoolSucceeded(job_status.jobId);
+          done = true;
+        } else {
+          ResetEvent(job_progress_event_.Get());
+          job_progress_watcher_.StopWatching();
+          job_progress_watcher_.StartWatching(job_progress_event_.Get(), this);
+        }
+        if (done && should_couninit_) {
+          CoUninitialize();
+          should_couninit_ = false;
+        }
+      }
+
       virtual void OnRenderPDFPagesToMetafileFailed() {
         PrintJobDone();
       }
       virtual void OnChildDied() {
         PrintJobDone();
       }
      private:
       void PrintJobDone() {
         // If there is no delegate, then there is nothing pending to process.
         if (!delegate_)
@@ skipping 41 matching lines @@
         scoped_ptr<ServiceUtilityProcessHost> utility_host(
             new ServiceUtilityProcessHost(this, client_message_loop_proxy));
         if (utility_host->StartRenderPDFPagesToMetafile(pdf_path,
                                                         render_area,
                                                         render_dpi,
                                                         page_ranges)) {
           // The object will self-destruct when the child process dies.
           utility_host.release();
         }
       }
+      bool PrintXPSDocument(const std::string& printer_name,
+                            const std::string& job_title,
+                            const FilePath& print_data_file_path,
+                            const std::string& print_ticket) {
+        if (!printing::XPSPrintModule::Init())
+          return false;
+        job_progress_event_.Set(CreateEvent(NULL, TRUE, FALSE, NULL));
+        if (!job_progress_event_.Get())
+          return false;
+        should_couninit_ = SUCCEEDED(CoInitializeEx(NULL,
+                                                    COINIT_MULTITHREADED));
+        ScopedComPtr<IXpsPrintJobStream> doc_stream;
+        ScopedComPtr<IXpsPrintJobStream> print_ticket_stream;
+        bool ret = false;
+        // Use nested SUCCEEDED checks because we want a common return point.
+        if (SUCCEEDED(printing::XPSPrintModule::StartXpsPrintJob(
+                UTF8ToWide(printer_name).c_str(),
+                UTF8ToWide(job_title).c_str(),
+                NULL,
+                job_progress_event_.Get(),
+                NULL,
+                NULL,
+                NULL,
+                xps_print_job_.Receive(),
+                doc_stream.Receive(),
+                print_ticket_stream.Receive()))) {
+          ULONG bytes_written = 0;
+          if (SUCCEEDED(print_ticket_stream->Write(print_ticket.c_str(),
+                                                   print_ticket.length(),
+                                                   &bytes_written))) {
+            DCHECK(bytes_written == print_ticket.length());
+            if (SUCCEEDED(print_ticket_stream->Close())) {
+              std::string document_data;
+              file_util::ReadFileToString(print_data_file_path, &document_data);

[Scott Byer, 2011/02/17 00:31:02]

Does this function need to check that it's being called on the right thread
since it's got file I/O going on?

[sanjeevr, 2011/02/17 00:53:52]

This is the service process and not the browser process. We don't have the same
kind of restrictions about which thread to do file I/O on since there is no UI.

+              bytes_written = 0;
+              if (SUCCEEDED(doc_stream->Write(document_data.c_str(),
+                                              document_data.length(),
+                                              &bytes_written))) {
+                DCHECK(bytes_written == document_data.length());
+                if (SUCCEEDED(doc_stream->Close())) {
+                  job_progress_watcher_.StartWatching(job_progress_event_.Get(),
+                                                      this);
+                  ret = true;
+                }
+              }
+            }
+          }
+        }
+        if (!ret) {
+          if (xps_print_job_) {
+            xps_print_job_->Cancel();
+            xps_print_job_.Release();
+          }
+          if (should_couninit_) {
+            CoUninitialize();
+            should_couninit_ = false;
+          }
+        }
+        return ret;
+      }
+
       // 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::ScopedHDC printer_dc_;
       FilePath print_data_file_path_;
+      base::win::ScopedHandle job_progress_event_;
+      base::win::ObjectWatcher job_progress_watcher_;
+      ScopedComPtr<IXpsPrintJob> xps_print_job_;
+      bool should_couninit_;
       DISALLOW_COPY_AND_ASSIGN(JobSpoolerWin::Core);
     };
     scoped_refptr<Core> core_;
     DISALLOW_COPY_AND_ASSIGN(JobSpoolerWin);
   };
 
   // A helper class to handle the response from the utility process to the
   // request to fetch printer capabilities and defaults.
   class PrinterCapsHandler : public ServiceUtilityProcessHost::Client {
    public:
@@ skipping 53 matching lines @@
 
     std::string printer_name_;
     scoped_ptr<PrinterCapsAndDefaultsCallback> callback_;
   };
 
 
   virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher();
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
       const std::string& printer_name);
   virtual PrintSystem::JobSpooler* CreateJobSpooler();
+  virtual std::string GetSupportedMimeTypes();
+
 
  private:
   scoped_refptr<printing::PrintBackend> print_backend_;
 };
 
 PrintSystemWin::PrintSystemWin() {
   print_backend_ = printing::PrintBackend::CreateInstance(NULL);
 }
 
 PrintSystem::PrintSystemResult PrintSystemWin::Init() {
@@ skipping 120 matching lines @@
     const std::string& printer_name) {
   DCHECK(!printer_name.empty());
   return new PrinterWatcherWin(printer_name);
 }
 
 PrintSystem::JobSpooler*
 PrintSystemWin::CreateJobSpooler() {
   return new JobSpoolerWin();
 }
 
+std::string PrintSystemWin::GetSupportedMimeTypes() {
+  if (printing::XPSPrintModule::Init())
+    return "application/vnd.ms-xpsdocument,application/pdf";
+  return "application/pdf";
+}
+
+
 std::string PrintSystem::GenerateProxyId() {
   GUID proxy_id = {0};
   HRESULT hr = UuidCreate(&proxy_id);
   DCHECK(SUCCEEDED(hr));
   wchar_t* proxy_id_as_string = NULL;
   UuidToString(&proxy_id, reinterpret_cast<RPC_WSTR *>(&proxy_id_as_string));
   DCHECK(proxy_id_as_string);
   std::string ret;
   WideToUTF8(proxy_id_as_string, wcslen(proxy_id_as_string), &ret);
   RpcStringFree(reinterpret_cast<RPC_WSTR *>(&proxy_id_as_string));
   return ret;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print