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

chrome/service/cloud_print/printer_job_handler.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/printer_job_handler.h"
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
       printer_id_(printer_id),
       auth_token_(auth_token),
       last_caps_hash_(caps_hash),
       cloud_print_server_url_(cloud_print_server_url),
       delegate_(delegate),
       local_job_id_(-1),
       next_response_handler_(NULL),
       next_failure_handler_(NULL),
       server_error_count_(0),
       print_thread_("Chrome_CloudPrintJobPrintThread"),
+      job_handler_message_loop_proxy_(
+          base::MessageLoopProxy::CreateForCurrentThread()),
       shutting_down_(false),
       server_job_available_(false),
       printer_update_pending_(true),
       printer_delete_pending_(false),
       task_in_progress_(false) {
 }
 
 bool PrinterJobHandler::Initialize() {
   if (print_system_->IsValidPrinter(printer_info_.printer_name)) {
     printer_watcher_ = print_system_->CreatePrinterWatcher(
@@ skipping 375 matching lines @@
 
 void PrinterJobHandler::StartPrinting() {
   LOG(INFO) << "CP_PROXY: Start printing, id: " << printer_id_;
   // We are done with the request object for now.
   request_.reset();
   if (!shutting_down_) {
     if (!print_thread_.Start()) {
       JobFailed(PRINT_FAILED);
     } else {
       print_thread_.message_loop()->PostTask(
-          FROM_HERE, NewRunnableFunction(&PrinterJobHandler::DoPrint,
-                                         job_details_,
-                                         printer_info_.printer_name,
-                                         print_system_, this,
-                                         MessageLoop::current()));
+          FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::DoPrint,
+                                       job_details_,
+                                       printer_info_.printer_name));
     }
   }
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
   LOG(INFO) << "CP_PROXY: Job failed, id: " << printer_id_;
   if (!shutting_down_) {
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
   }
 }
@@ skipping 134 matching lines @@
 }
 
 void PrinterJobHandler::FailedFetchingJobData() {
   if (!shutting_down_) {
     LOG(ERROR) << "CP_PROXY: Failed fetching job data for printer: " <<
         printer_info_.printer_name << ", job id: " << job_details_.job_id_;
     JobFailed(INVALID_JOB_DATA);
   }
 }
 
+// The following methods are called on |print_thread_|. It is not safe to
+// access any members other than |job_handler_message_loop_proxy_|,
+// |job_spooler_| and |print_system_|.
 void PrinterJobHandler::DoPrint(const JobDetails& job_details,
-                          const std::string& printer_name,
-                          scoped_refptr<cloud_print::PrintSystem> print_system,
-                          PrinterJobHandler* job_handler,
-                          MessageLoop* job_message_loop) {
-  DCHECK(job_handler);
-  DCHECK(job_message_loop);
-  LOG(INFO) << "CP_PROXY: Printing: " << printer_name;
-  cloud_print::PlatformJobId job_id = -1;
-  if (print_system->SpoolPrintJob(job_details.print_ticket_,
-                                  job_details.print_data_file_path_,
-                                  job_details.print_data_mime_type_,
-                                  printer_name,
-                                  job_details.job_title_, &job_id)) {
-    job_message_loop->PostTask(FROM_HERE,
-                               NewRunnableMethod(job_handler,
-                                                 &PrinterJobHandler::JobSpooled,
-                                                 job_id));
+                                const std::string& printer_name) {
+  job_spooler_ = print_system_->CreateJobSpooler();
+  DCHECK(job_spooler_);
+  if (job_spooler_) {
+    job_spooler_->Spool(job_details.print_ticket_,
+                        job_details.print_data_file_path_,
+                        job_details.print_data_mime_type_,
+                        printer_name,
+                        job_details.job_title_,
+                        this);
   } else {
-    job_message_loop->PostTask(FROM_HERE,
-                               NewRunnableMethod(job_handler,
-                                                 &PrinterJobHandler::JobFailed,
-                                                 PRINT_FAILED));
+    OnJobSpoolFailed();
   }
 }
 
+void PrinterJobHandler::OnJobSpoolSucceeded(
+    const cloud_print::PlatformJobId& job_id) {
+  DCHECK(MessageLoop::current() == print_thread_.message_loop());
+  job_spooler_ = NULL;
+  job_handler_message_loop_proxy_->PostTask(FROM_HERE,
+                                            NewRunnableMethod(this,
+                                                &PrinterJobHandler::JobSpooled,
+                                                job_id));
+}
+
+void PrinterJobHandler::OnJobSpoolFailed() {
+  DCHECK(MessageLoop::current() == print_thread_.message_loop());
+  job_spooler_ = NULL;
+  job_handler_message_loop_proxy_->PostTask(FROM_HERE,
+                                            NewRunnableMethod(this,
+                                                &PrinterJobHandler::JobFailed,
+                                                PRINT_FAILED));
+}
+