Making CUPS calls non-blocking....

printing/backend/print_backend_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 "printing/backend/print_backend.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #if !defined(OS_MACOSX)
 #include <gcrypt.h>
 #endif
 #include <pthread.h>
 
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
 #include "printing/backend/cups_helper.h"
+#include "printing/backend/print_backend_consts.h"
 
 #if !defined(OS_MACOSX)
 GCRY_THREAD_OPTION_PTHREAD_IMPL;
 
 namespace {
 
 // Init GCrypt library (needed for CUPS) using pthreads.
 // There exists a bug in CUPS library, where it crashed with: "ath.c:184:
 // _gcry_ath_mutex_lock: Assertion `*lock == ((ath_mutex_t) 0)' failed."
 // It happened when multiple threads tried printing simultaneously.
@@ skipping 37 matching lines @@
 static base::LazyInstance<GcryptInitializer> g_gcrypt_initializer(
     base::LINKER_INITIALIZED);
 
 }  // namespace
 #endif
 
 namespace printing {
 
 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 static const char kCUPSPrinterStateOpt[] = "printer-state";
-static const char kCUPSPrintServerURL[] = "print_server_url";
 
 class PrintBackendCUPS : public PrintBackend {
  public:
-  explicit PrintBackendCUPS(const GURL& print_server_url);
+  PrintBackendCUPS(const GURL& print_server_url, bool blocking);
   virtual ~PrintBackendCUPS() {}
 
   // PrintBackend implementation.
   virtual void EnumeratePrinters(PrinterList* printer_list);
 
   virtual bool GetPrinterCapsAndDefaults(const std::string& printer_name,
                                          PrinterCapsAndDefaults* printer_info);
 
   virtual bool IsValidPrinter(const std::string& printer_name);
 
  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);
 
   GURL print_server_url_;
+  bool blocking_;
 };
 
-PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url)
-    : print_server_url_(print_server_url) {
+PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url, bool blocking)
+    : print_server_url_(print_server_url), blocking_(blocking) {
 }
 
 void PrintBackendCUPS::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
   printer_list->clear();
 
   cups_dest_t* destinations = NULL;
   int num_dests = GetDests(&destinations);
 
   for (int printer_index = 0; printer_index < num_dests; printer_index++) {
@@ skipping 70 matching lines @@
   return false;
 }
 
 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
     const DictionaryValue* print_backend_settings) {
 #if !defined(OS_MACOSX)
   // Initialize gcrypt library.
   g_gcrypt_initializer.Get();
 #endif
 
-  std::string print_server_url_str;
+  std::string print_server_url_str, cups_blocking;
   if (print_backend_settings) {
     print_backend_settings->GetString(kCUPSPrintServerURL,
                                       &print_server_url_str);
+
+    print_backend_settings->GetString(kCUPSBlocking,
+                                      &cups_blocking);
   }
   GURL print_server_url(print_server_url_str.c_str());
-  return new PrintBackendCUPS(print_server_url);
+  return new PrintBackendCUPS(print_server_url, cups_blocking == kValueTrue);
 }
 
 int PrintBackendCUPS::GetDests(cups_dest_t** dests) {
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     return cupsGetDests(dests);
   } else {
     HttpConnectionCUPS http(print_server_url_);
+    http.SetBlocking(blocking_);
     return cupsGetDests2(http.http(), dests);
   }
 }
 
 FilePath PrintBackendCUPS::GetPPD(const char* name) {
   // cupsGetPPD returns a filename stored in a static buffer in CUPS.
   // Protect this code with lock.
   static Lock ppd_lock;
   AutoLock ppd_autolock(ppd_lock);
   FilePath ppd_path;
   const char* ppd_file_path = NULL;
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     ppd_file_path = cupsGetPPD(name);
     if (ppd_file_path)
       ppd_path = FilePath(ppd_file_path);
   } else {
     // cupsGetPPD2 gets stuck sometimes in an infinite time due to network
     // configuration/issues. To prevent that, use non-blocking http connection
     // here.
     // Note: After looking at CUPS sources, it looks like non-blocking
     // connection will timeout after 10 seconds of no data period. And it will
     // return the same way as if data was completely and sucessfully downloaded.
     // To distinguish error case from the normal return, will check result file
     // size agains content length.
     HttpConnectionCUPS http(print_server_url_);
-    http.SetBlocking(false);
+    http.SetBlocking(blocking_);
     ppd_file_path = cupsGetPPD2(http.http(), name);
     // Check if the get full PPD, since non-blocking call may simply return
     // normally after timeout expired.
     if (ppd_file_path) {
       ppd_path = FilePath(ppd_file_path);
       off_t content_len = httpGetLength2(http.http());
       int64 ppd_size = 0;
       // This is a heuristic to detect if we reached timeout. If we see content
       // length is larger that the actual file we downloaded it means timeout
       // reached. Sometimes http can be compressed, and in that case the
       // the content length will be smaller than the actual payload (not sure
       // if CUPS support such responses).
       if (!file_util::GetFileSize(ppd_path, &ppd_size) ||
           content_len > ppd_size) {
         LOG(ERROR) << "Error downloading PPD file for: " << name
                    << ", file size: "  << ppd_size
                    << ", content length: " << content_len;
         file_util::Delete(ppd_path, false);
         ppd_path.clear();
       }
     }
   }
   return ppd_path;
 }
 
 }  // namespace printing