Adding functionality to specify TLS encryption CUPS print servers for cloudprint connector.

printing/backend/print_backend_cups.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 84 matching lines @@
 
 namespace printing {
 
 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 static const char kCUPSPrinterStateOpt[] = "printer-state";
 static const char kCUPSPrinterTypeOpt[] = "printer-type";
 static const char kCUPSPrinterMakeModelOpt[] = "printer-make-and-model";
 
 class PrintBackendCUPS : public PrintBackend {
  public:
-  PrintBackendCUPS(const GURL& print_server_url, bool blocking);
+  PrintBackendCUPS(const GURL& print_server_url,
+                   http_encryption_t encryption, bool blocking);

[Ryan Sleevi, 2012/05/17 00:35:27]

style nit: put "bool blocking" on a new line, per

http://dev.chromium.org/developers/coding-style

(See "For function declarations and definitions" ...)

 
   // PrintBackend implementation.
   virtual bool EnumeratePrinters(PrinterList* printer_list) OVERRIDE;
   virtual std::string GetDefaultPrinterName() OVERRIDE;
   virtual bool GetPrinterCapsAndDefaults(
       const std::string& printer_name,
       PrinterCapsAndDefaults* printer_info) OVERRIDE;
   virtual std::string GetPrinterDriverInfo(
       const std::string& printer_name) OVERRIDE;
   virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE;
 
  protected:
   virtual ~PrintBackendCUPS() {}
 
  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_;
+  http_encryption_t cups_encryption_;
   bool blocking_;
 };
 
-PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url, bool blocking)
-    : print_server_url_(print_server_url), blocking_(blocking) {
+PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url,
+                                   http_encryption_t encryption,
+                                   bool blocking)
+    : print_server_url_(print_server_url),
+      cups_encryption_(encryption),
+      blocking_(blocking) {
 }
 
 bool PrintBackendCUPS::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
   printer_list->clear();
 
   cups_dest_t* destinations = NULL;
   int num_dests = GetDests(&destinations);
   if ((num_dests == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE)) {
     VLOG(1) << "CP_CUPS: Error getting printers from CUPS server. Server: "
@@ skipping 124 matching lines @@
 }
 
 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, cups_blocking;
+  int encryption = HTTP_ENCRYPT_NEVER;
   if (print_backend_settings) {
     print_backend_settings->GetString(kCUPSPrintServerURL,
                                       &print_server_url_str);
 
     print_backend_settings->GetString(kCUPSBlocking,
                                       &cups_blocking);
+
+    print_backend_settings->GetInteger(kCUPSEncryption, &encryption);
   }
   GURL print_server_url(print_server_url_str.c_str());
-  return new PrintBackendCUPS(print_server_url, cups_blocking == kValueTrue);
+  return new PrintBackendCUPS(print_server_url,
+                              static_cast<http_encryption_t>(encryption),
+                              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_);
+    HttpConnectionCUPS http(print_server_url_, cups_encryption_);
     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.
   CR_DEFINE_STATIC_LOCAL(base::Lock, ppd_lock, ());
   base::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.
-    HttpConnectionCUPS http(print_server_url_);
+    HttpConnectionCUPS http(print_server_url_, cups_encryption_);
     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) {
       // There is no reliable way right now to detect full and complete PPD
       // get downloaded. If we reach http timeout, it may simply return
       // downloaded part as a full response. It might be good enough to check
       // http->data_remaining or http->_data_remaining, unfortunately http_t
       // is an internal structure and fields are not exposed in CUPS headers.
@@ skipping 10 matching lines @@
                    << ", HTTP error: " << http_error;
         file_util::Delete(ppd_path, false);
         ppd_path.clear();
       }
     }
   }
   return ppd_path;
 }
 
 }  // namespace printing