As the first step in an effort to improve robustness of the cloud print proxy...

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>
 
 #include "base/file_path.h"
@@ skipping 227 matching lines @@
 
 class PrintSystemWin : public PrintSystem {
  public:
   PrintSystemWin();
 
   // PrintSystem implementation.
   virtual void Init();
 
   virtual void EnumeratePrinters(printing::PrinterList* printer_list);
 
-  virtual bool GetPrinterCapsAndDefaults(
+  virtual void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
-      printing::PrinterCapsAndDefaults* printer_info);
+      PrinterCapsAndDefaultsCallback* callback);
 
   virtual bool IsValidPrinter(const std::string& printer_name);
 
   virtual bool ValidatePrintTicket(const std::string& printer_name,
                                    const std::string& print_ticket_data);
 
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
                              PrintJobDetails *job_details);
 
@@ skipping 248 matching lines @@
       PrintSystem::JobSpooler::Delegate* delegate_;
       int saved_dc_;
       ScopedHDC printer_dc_;
       FilePath print_data_file_path_;
       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:
+    PrinterCapsHandler(
+        const std::string& printer_name,
+        PrinterCapsAndDefaultsCallback* callback)
+            : printer_name_(printer_name), callback_(callback) {
+    }
+    virtual void Start() {
+      g_service_process->io_thread()->message_loop_proxy()->PostTask(
+          FROM_HERE,
+          NewRunnableMethod(
+              this,
+              &PrinterCapsHandler::GetPrinterCapsAndDefaultsImpl,
+              base::MessageLoopProxy::CreateForCurrentThread()));
+    }
+
+    virtual void OnChildDied() {
+      OnGetPrinterCapsAndDefaultsFailed(printer_name_);
+    }
+    virtual void OnGetPrinterCapsAndDefaultsSucceeded(
+        const std::string& printer_name,
+        const printing::PrinterCapsAndDefaults& caps_and_defaults) {
+      callback_->Run(true, printer_name, caps_and_defaults);
+      callback_.reset();
+      Release();
+    }
+
+    virtual void OnGetPrinterCapsAndDefaultsFailed(
+        const std::string& printer_name) {
+      printing::PrinterCapsAndDefaults caps_and_defaults;
+      callback_->Run(false, printer_name, caps_and_defaults);
+      callback_.reset();
+      Release();
+    }
+   private:
+      // Called on the service process IO thread.
+    void GetPrinterCapsAndDefaultsImpl(
+        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));
+      if (utility_host->StartGetPrinterCapsAndDefaults(printer_name_)) {
+        // The object will self-destruct when the child process dies.
+        utility_host.release();
+      } else {
+        client_message_loop_proxy->PostTask(
+            FROM_HERE,
+            NewRunnableMethod(
+                this,
+                &PrinterCapsHandler::OnGetPrinterCapsAndDefaultsFailed,
+                printer_name_));
+      }
+    }
+
+    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();
 
  private:
   scoped_refptr<printing::PrintBackend> print_backend_;
 };
 
 PrintSystemWin::PrintSystemWin() {
   print_backend_ = printing::PrintBackend::CreateInstance(NULL);
 }
 
 void PrintSystemWin::Init() {
 }
 
 void PrintSystemWin::EnumeratePrinters(printing::PrinterList* printer_list) {
   print_backend_->EnumeratePrinters(printer_list);
 }
 
-bool PrintSystemWin::GetPrinterCapsAndDefaults(
+void PrintSystemWin::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
-    printing::PrinterCapsAndDefaults* printer_info) {
-  return print_backend_->GetPrinterCapsAndDefaults(printer_name, printer_info);
+    PrinterCapsAndDefaultsCallback* callback) {
+  // Launch as child process to retrieve the capabilities and defaults because
+  // this involves invoking a printer driver DLL and crashes have been known to
+  // occur.
+  PrinterCapsHandler* handler =
+      new PrinterCapsHandler(printer_name, callback);
+  handler->AddRef();
+  handler->Start();
 }
 
 bool PrintSystemWin::IsValidPrinter(const std::string& printer_name) {
   return print_backend_->IsValidPrinter(printer_name);
 }
 
 bool PrintSystemWin::ValidatePrintTicket(
     const std::string& printer_name,
     const std::string& print_ticket_data) {
   if (!printing::XPSModule::Init()) {
@@ skipping 104 matching lines @@
   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