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

chrome/service/cloud_print/print_system_cups.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 <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <gcrypt.h>
@@ skipping 106 matching lines @@
   }
 
  private:
   http_t* http_;
 };
 
 class PrintSystemCUPS : public PrintSystem {
  public:
   explicit PrintSystemCUPS(const GURL& print_server_url);
 
+  // PrintSystem implementation.
   virtual void EnumeratePrinters(PrinterList* printer_list);
 
   virtual bool GetPrinterCapsAndDefaults(const std::string& printer_name,
                                          PrinterCapsAndDefaults* printer_info);
 
   virtual bool ValidatePrintTicket(const std::string& printer_name,
                                    const std::string& print_ticket_data);
 
-  virtual bool SpoolPrintJob(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,
-                             PlatformJobId* job_id_ret);
-
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
                              PrintJobDetails *job_details);
 
   virtual bool IsValidPrinter(const std::string& printer_name);
 
+
   // TODO(gene): Add implementation for CUPS print server watcher.
   class PrintServerWatcherCUPS
     : public PrintSystem::PrintServerWatcher {
    public:
     PrintServerWatcherCUPS() {}
 
     // PrintSystem::PrintServerWatcher interface
     virtual bool StartWatching(
         PrintSystem::PrintServerWatcher::Delegate* delegate) {
       NOTIMPLEMENTED();
@@ skipping 47 matching lines @@
           kNotificationTimeout);
     }
    private:
     static const int kNotificationTimeout = 5000;  // in ms
     std::string printer_name_;
     PrintSystem::PrinterWatcher::Delegate* delegate_;
     scoped_refptr<PrintSystemCUPS> print_system_;
     DISALLOW_COPY_AND_ASSIGN(PrinterWatcherCUPS);
   };
 
+  class JobSpoolerCUPS : public PrintSystem::JobSpooler {
+   public:
+    explicit JobSpoolerCUPS(PrintSystemCUPS* print_system)
+        : print_system_(print_system) {
+      DCHECK(print_system_.get());
+    }
+    // PrintSystem::JobSpooler implementation.
+    virtual 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) {
+      DCHECK(delegate);
+      int job_id = print_system_->SpoolPrintJob(
+          print_ticket, print_data_file_path, print_data_mime_type,
+          printer_name, job_title);
+      MessageLoop::current()->PostTask(FROM_HERE,
+                                       NewRunnableFunction(
+                                           &JobSpoolerCUPS::NotifyDelegate,
+                                           delegate,
+                                           job_id));
+      return true;
+    }
+
+    static void NotifyDelegate(JobSpooler::Delegate* delegate, int job_id) {
+      if (job_id)
+        delegate->OnJobSpoolSucceeded(job_id);
+      else
+        delegate->OnJobSpoolFailed();
+    }
+   private:
+    scoped_refptr<PrintSystemCUPS> print_system_;
+    DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
+  };
+
   virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher();
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
       const std::string& printer_name);
+  virtual PrintSystem::JobSpooler* CreateJobSpooler();
 
   // Helper functions.
+  PlatformJobId SpoolPrintJob(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);
   bool GetPrinterInfo(const std::string& printer_name, PrinterBasicInfo* info);
   bool ParsePrintTicket(const std::string& print_ticket,
                         std::map<std::string, std::string>* options);
 
  private:
   // Following functions are wrappers around corresponding CUPS functions.
   // <functions>2()  are called when print server is specified, and plain
   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
   // in the <functions>2(), it does not work in CUPS prior to 1.4.
   int GetDests(cups_dest_t** dests);
   FilePath GetPPD(const char* name);
+  int GetJobs(cups_job_t** jobs, const char* name,
+              int myjobs, int whichjobs);
   int PrintFile(const char* name, const char* filename, const char* title,
                 int num_options, cups_option_t* options);
-  int GetJobs(cups_job_t** jobs, const char* name,
-              int myjobs, int whichjobs);
 
   GURL print_server_url_;
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const GURL& print_server_url)
     : print_server_url_(print_server_url) {
 }
 
 void PrintSystemCUPS::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
@@ skipping 84 matching lines @@
     std::wstring key = *it;
     std::string value;
     if (ticket_dict->GetString(key, &value)) {
       (*options)[WideToUTF8(key.c_str())] = value;
     }
   }
 
   return true;
 }
 
-bool PrintSystemCUPS::SpoolPrintJob(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,
-                                    PlatformJobId* job_id_ret) {
-  DCHECK(job_id_ret);
-
-  LOG(INFO) << "CP_CUPS: Spooling print job for: " << printer_name;
-
-  // We need to store options as char* string for the duration of the
-  // cupsPrintFile2 call. We'll use map here to store options, since
-  // Dictionary value from JSON parser returns wchat_t.
-  std::map<std::string, std::string> options;
-  bool res = ParsePrintTicket(print_ticket, &options);
-  DCHECK(res);  // If print ticket is invalid we still print using defaults.
-
-  std::vector<cups_option_t> cups_options;
-  std::map<std::string, std::string>::iterator it;
-  for (it = options.begin(); it != options.end(); ++it) {
-    cups_option_t opt;
-    opt.name = const_cast<char*>(it->first.c_str());
-    opt.value = const_cast<char*>(it->second.c_str());
-    cups_options.push_back(opt);
-  }
-
-  int job_id = PrintFile(printer_name.c_str(),
-                         print_data_file_path.value().c_str(),
-                         job_title.c_str(),
-                         cups_options.size(),
-                         &(cups_options[0]));
-
-  LOG(INFO) << "CP_CUPS: Job spooled, id: " << job_id;
-
-  if (job_id == 0)
-    return false;
-
-  *job_id_ret = job_id;
-  return true;
-}
-
 bool PrintSystemCUPS::GetJobDetails(const std::string& printer_name,
                                     PlatformJobId job_id,
                                     PrintJobDetails *job_details) {
   DCHECK(job_details);
 
   cups_job_t* jobs = NULL;
   int num_jobs = GetJobs(&jobs, printer_name.c_str(), 1, -1);
 
   bool found = false;
   for (int i = 0; i < num_jobs; i++) {
@@ skipping 65 matching lines @@
 PrintSystemCUPS::CreatePrintServerWatcher() {
   return new PrintServerWatcherCUPS();
 }
 
 PrintSystem::PrinterWatcher* PrintSystemCUPS::CreatePrinterWatcher(
     const std::string& printer_name) {
   DCHECK(!printer_name.empty());
   return new PrinterWatcherCUPS(this, printer_name);
 }
 
+PrintSystem::JobSpooler* PrintSystemCUPS::CreateJobSpooler() {
+  return new JobSpoolerCUPS(this);
+}
+
 std::string PrintSystem::GenerateProxyId() {
   // TODO(gene): This code should generate a unique id for proxy. ID should be
   // unique for this user. Rand may return the same number. We'll need to change
   // this in the future.
   std::string id("CP_PROXY_");
   id += Uint64ToString(base::RandUint64());
   return id;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
@@ skipping 52 matching lines @@
 int PrintSystemCUPS::GetJobs(cups_job_t** jobs, const char* name,
                              int myjobs, int whichjobs) {
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     return cupsGetJobs(jobs, name, myjobs, whichjobs);
   } else {
     HttpConnectionCUPS http(print_server_url_);
     return cupsGetJobs2(http.http(), jobs, name, myjobs, whichjobs);
   }
 }
 
+PlatformJobId PrintSystemCUPS::SpoolPrintJob(
+    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) {
+  LOG(INFO) << "CP_CUPS: Spooling print job for: " << printer_name;
+
+  // We need to store options as char* string for the duration of the
+  // cupsPrintFile2 call. We'll use map here to store options, since
+  // Dictionary value from JSON parser returns wchat_t.
+  std::map<std::string, std::string> options;
+  bool res = ParsePrintTicket(print_ticket, &options);
+  DCHECK(res);  // If print ticket is invalid we still print using defaults.
+
+  std::vector<cups_option_t> cups_options;
+  std::map<std::string, std::string>::iterator it;
+  for (it = options.begin(); it != options.end(); ++it) {
+    cups_option_t opt;
+    opt.name = const_cast<char*>(it->first.c_str());
+    opt.value = const_cast<char*>(it->second.c_str());
+    cups_options.push_back(opt);
+  }
+
+  int job_id = PrintFile(printer_name.c_str(),
+                         print_data_file_path.value().c_str(),
+                         job_title.c_str(),
+                         cups_options.size(),
+                         &(cups_options[0]));
+
+  LOG(INFO) << "CP_CUPS: Job spooled, id: " << job_id;
+
+  return job_id;
+}
+
 }  // namespace cloud_print