Used the service utility process host to render PDFs in a sandbox for the Win...

chrome/service/cloud_print/printer_job_handler.h

 // 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.
 
 #ifndef CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_
 #define CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_
 
 #include <list>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/ref_counted.h"
+#include "base/message_loop_proxy.h"
 #include "base/thread.h"
 #include "chrome/service/cloud_print/job_status_updater.h"
 #include "chrome/service/cloud_print/print_system.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
 
 // A class that handles cloud print jobs for a particular printer. This class
 // imlements a state machine that transitions from Start to various states. The
 // various states are shown in the below diagram.
@@ skipping 31 matching lines @@
 //                              |
 //                              |
 //                             Stop
 //               (If there are pending tasks go back to Start)
 
 typedef URLFetcher::Delegate URLFetcherDelegate;
 
 class PrinterJobHandler : public base::RefCountedThreadSafe<PrinterJobHandler>,
                           public URLFetcherDelegate,
                           public JobStatusUpdaterDelegate,
-                          public cloud_print::PrinterWatcherDelegate {
+                          public cloud_print::PrinterWatcherDelegate,
+                          public cloud_print::JobSpoolerDelegate {
   enum PrintJobError {
     SUCCESS,
     JOB_DOWNLOAD_FAILED,
     INVALID_JOB_DATA,
     PRINT_FAILED,
   };
   struct JobDetails {
     std::string job_id_;
     std::string job_title_;
     std::string print_ticket_;
@@ skipping 39 matching lines @@
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
   // JobStatusUpdater::Delegate implementation
   virtual bool OnJobCompleted(JobStatusUpdater* updater);
   // cloud_print::PrinterWatcherDelegate implementation
   virtual void OnPrinterDeleted();
   virtual void OnPrinterChanged();
   virtual void OnJobChanged();
 
+  // cloud_print::JobSpoolerDelegate implementation.
+  // Called on print_thread_.
+  virtual void OnJobSpoolSucceeded(const cloud_print::PlatformJobId& job_id);
+  virtual void OnJobSpoolFailed();
+
   // End Delegate implementations
 
  private:
   // Prototype for a response handler. The return value indicates whether the
   // request should be retried, false means "retry", true means "do not retry"
   typedef bool (PrinterJobHandler::*ResponseHandler)(
       const URLFetcher* source, const GURL& url,
       const URLRequestStatus& status, int response_code,
       const ResponseCookies& cookies, const std::string& data);
   // Prototype for a failure handler. This handler will be executed if all
@@ skipping 66 matching lines @@
   // to decide which handler to call.
   void FetchURL(const GURL& url);
 
   void JobFailed(PrintJobError error);
   void JobSpooled(cloud_print::PlatformJobId local_job_id);
   // Returns false if printer info is up to date and no updating is needed.
   bool UpdatePrinterInfo();
   bool HavePendingTasks();
   void FailedFetchingJobData();
 
-  static void DoPrint(const JobDetails& job_details,
-                      const std::string& printer_name,
-                      scoped_refptr<cloud_print::PrintSystem> print_system,
-                      PrinterJobHandler* job_handler,
-                      MessageLoop* job_message_loop);
+  // Called on print_thread_.
+  void DoPrint(const JobDetails& job_details,
+               const std::string& printer_name);
 
   scoped_ptr<URLFetcher> request_;
   scoped_refptr<cloud_print::PrintSystem> print_system_;
   cloud_print::PrinterBasicInfo printer_info_;
   std::string printer_id_;
   std::string auth_token_;
   std::string last_caps_hash_;
   GURL cloud_print_server_url_;
   std::string print_data_url_;
   JobDetails job_details_;
   Delegate* delegate_;
   // Once the job has been spooled to the local spooler, this specifies the
   // job id of the job on the local spooler.
   cloud_print::PlatformJobId local_job_id_;
   ResponseHandler next_response_handler_;
   FailureHandler next_failure_handler_;
   // The number of consecutive times that connecting to the server failed.
   int server_error_count_;
   // The thread on which the actual print operation happens
   base::Thread print_thread_;
+  // The Job spooler object. This is only non-NULL during a print operation.
+  // It lives and dies on |print_thread_|
+  scoped_refptr<cloud_print::PrintSystem::JobSpooler> job_spooler_;
+  // The message loop proxy representing the thread on which this object
+  // was created. Used by the print thread.
+  scoped_refptr<base::MessageLoopProxy> job_handler_message_loop_proxy_;
+
   // There may be pending tasks in the message queue when Shutdown is called.
   // We set this flag so as to do nothing in those tasks.
   bool shutting_down_;
 
   // Flags that specify various pending server updates
   bool server_job_available_;
   bool printer_update_pending_;
   bool printer_delete_pending_;
 
   // Some task in the state machine is in progress.
   bool task_in_progress_;
   scoped_refptr<cloud_print::PrintSystem::PrinterWatcher> printer_watcher_;
   typedef std::list< scoped_refptr<JobStatusUpdater> > JobStatusUpdaterList;
   JobStatusUpdaterList job_status_updater_list_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterJobHandler);
 };
 
 // This typedef is to workaround the issue with certain versions of
 // Visual Studio where it gets confused between multiple Delegate
 // classes and gives a C2500 error. (I saw this error on the try bots -
 // the workaround was not needed for my machine).
 typedef PrinterJobHandler::Delegate PrinterJobHandlerDelegate;
 
 #endif  // CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_