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

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 <pthread.h>
@@ skipping 58 matching lines @@
 
 class PrintSystemCUPS : public PrintSystem {
  public:
   explicit PrintSystemCUPS(const DictionaryValue* print_system_settings);
 
   // 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);
 
   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,
                               const std::vector<std::string>& tags,
                               bool* dry_run);
   bool GetPrinterInfo(const std::string& printer_name,
                       printing::PrinterBasicInfo* info);
   bool ParsePrintTicket(const std::string& print_ticket,
                         std::map<std::string, std::string>* options);
 
+  // Synchronous version of GetPrinterCapsAndDefaults.
+  bool GetPrinterCapsAndDefaults(
+      const std::string& printer_name,
+      printing::PrinterCapsAndDefaults* printer_info);
+
   int GetUpdateTimeoutMs() const {
     return update_timeout_;
   }
 
  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 GetJobs(cups_job_t** jobs, const GURL& url, const char* name,
               int myjobs, int whichjobs);
   int PrintFile(const GURL& url, const char* name, const char* filename,
                 const char* title, int num_options, cups_option_t* options);
 
   void InitPrintBackends(const DictionaryValue* print_system_settings);
   void AddPrintServer(const std::string& url);
 
   void UpdatePrinters();
 
   // Full name contains print server url:port and printer name. Short name
   // is the name of the printer in the CUPS server.
   std::string MakeFullPrinterName(const GURL& url,
                                   const std::string& short_printer_name);
   PrintServerInfoCUPS* FindServerByFullName(
       const std::string& full_printer_name, std::string* short_printer_name);
 
+  // Helper method to invoke a PrinterCapsAndDefaultsCallback.
+  static void RunCapsCallback(
+      PrinterCapsAndDefaultsCallback* callback,
+      bool succeeded,
+      const std::string& printer_name,
+      const printing::PrinterCapsAndDefaults& printer_info);
+
   // PrintServerList contains information about all print servers and backends
   // this proxy is connected to.
   typedef std::list<PrintServerInfoCUPS> PrintServerList;
   PrintServerList print_servers_;
 
   int update_timeout_;
   bool initialized_;
 };
 
 class PrintServerWatcherCUPS
@@ skipping 277 matching lines @@
   DCHECK(initialized_);
   printer_list->clear();
   PrintServerList::iterator it;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     printer_list->insert(printer_list->end(),
         it->printers.begin(), it->printers.end());
   }
   VLOG(1) << "CUPS: Total " << printer_list->size() << " printers enumerated.";
 }
 
-bool PrintSystemCUPS::GetPrinterCapsAndDefaults(
+void PrintSystemCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
-    printing::PrinterCapsAndDefaults* printer_info) {
-  DCHECK(initialized_);
-  std::string short_printer_name;
-  PrintServerInfoCUPS* server_info =
-      FindServerByFullName(printer_name, &short_printer_name);
-  if (!server_info)
-    return false;
-
-  PrintServerInfoCUPS::CapsMap::iterator caps_it =
-      server_info->caps_cache.find(printer_name);
-  if (caps_it != server_info->caps_cache.end()) {
-    *printer_info = caps_it->second;
-    return true;
-  }
-
-  // TODO(gene): Retry multiple times in case of error.
-  if (!server_info->backend->GetPrinterCapsAndDefaults(short_printer_name,
-                                                       printer_info) ) {
-    return false;
-  }
-
-  server_info->caps_cache[printer_name] = *printer_info;
-  return true;
+    PrinterCapsAndDefaultsCallback* callback) {
+  printing::PrinterCapsAndDefaults printer_info;
+  bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      NewRunnableFunction(&PrintSystemCUPS::RunCapsCallback,
+                          callback,
+                          succeeded,
+                          printer_name,
+                          printer_info));
 }
 
 bool PrintSystemCUPS::IsValidPrinter(const std::string& printer_name) {
   return GetPrinterInfo(printer_name, NULL);
 }
 
 bool PrintSystemCUPS::ValidatePrintTicket(const std::string& printer_name,
                                         const std::string& print_ticket_data) {
   DCHECK(initialized_);
   scoped_ptr<Value> ticket_value(base::JSONReader::Read(print_ticket_data,
@@ skipping 17 matching lines @@
     const std::string& key = *it;
     std::string value;
     if (ticket_dict->GetString(key, &value)) {
       (*options)[key] = value;
     }
   }
 
   return true;
 }
 
+bool PrintSystemCUPS::GetPrinterCapsAndDefaults(
+    const std::string& printer_name,
+    printing::PrinterCapsAndDefaults* printer_info) {
+  DCHECK(initialized_);
+  std::string short_printer_name;
+  PrintServerInfoCUPS* server_info =
+      FindServerByFullName(printer_name, &short_printer_name);
+  if (!server_info)
+    return false;
+
+  PrintServerInfoCUPS::CapsMap::iterator caps_it =
+      server_info->caps_cache.find(printer_name);
+  if (caps_it != server_info->caps_cache.end()) {
+    *printer_info = caps_it->second;
+    return true;
+  }
+
+  // TODO(gene): Retry multiple times in case of error.
+  if (!server_info->backend->GetPrinterCapsAndDefaults(short_printer_name,
+                                                       printer_info) ) {
+    return false;
+  }
+
+  server_info->caps_cache[printer_name] = *printer_info;
+  return true;
+}
+
 bool PrintSystemCUPS::GetJobDetails(const std::string& printer_name,
                                     PlatformJobId job_id,
                                     PrintJobDetails *job_details) {
   DCHECK(initialized_);
   DCHECK(job_details);
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
@@ skipping 225 matching lines @@
     if (cur_server == server) {
       *short_printer_name = full_printer_name.substr(separator + 1);
       return &(*it);
     }
   }
 
   LOG(WARNING) << "Server not found for printer: " << full_printer_name;
   return NULL;
 }
 
+void PrintSystemCUPS::RunCapsCallback(
+    PrinterCapsAndDefaultsCallback* callback,
+    bool succeeded,
+    const std::string& printer_name,
+    const printing::PrinterCapsAndDefaults& printer_info) {
+  callback->Run(succeeded, printer_name, printer_info);
+  delete callback;
+}
+
 }  // namespace cloud_print