Use cupsGetNamedDest() in PrintBackendCUPS.

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 <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
 
@@ skipping 13 matching lines @@
 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,
                    http_encryption_t encryption, bool blocking);
 
+ private:
+  ~PrintBackendCUPS() override {}
+
   // PrintBackend implementation.
   bool EnumeratePrinters(PrinterList* printer_list) override;
   std::string GetDefaultPrinterName() override;
   bool GetPrinterSemanticCapsAndDefaults(
       const std::string& printer_name,
       PrinterSemanticCapsAndDefaults* printer_info) override;
   bool GetPrinterCapsAndDefaults(const std::string& printer_name,
                                  PrinterCapsAndDefaults* printer_info) override;
   std::string GetPrinterDriverInfo(const std::string& printer_name) override;
   bool IsValidPrinter(const std::string& printer_name) override;
 
- protected:
-  ~PrintBackendCUPS() override {}
-
- 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.
+  // The following functions are wrappers around corresponding CUPS functions.

[Lei Zhang, 2016/05/16 18:43:18]

Despite being "wrappers", these two methods are not trivial, so it's not obvious
if we can simply remove them just yet. Leaving them alone for now.

+  // <functions>2() are called when print server is specified, and plain version
+  // in another case. There is an issue specifying CUPS_HTTP_DEFAULT in the
+  // functions>2(), it does not work in CUPS prior to 1.4.
   int GetDests(cups_dest_t** dests);
   base::FilePath GetPPD(const char* name);
 
+  // Wrapper around cupsGetNamedDest(). Returned result should be freed with
+  // cupsFreeDests().
+  cups_dest_t* GetNamedDest(const std::string& printer_name);
+
   GURL print_server_url_;
   http_encryption_t cups_encryption_;
   bool 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;
+  cups_dest_t* destinations = nullptr;
   int num_dests = GetDests(&destinations);
-  if ((num_dests == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE)) {
+  if (!num_dests && cupsLastError() > IPP_OK_EVENTS_COMPLETE) {
     VLOG(1) << "CUPS: Error getting printers from CUPS server"
             << ", server: " << print_server_url_
             << ", error: " << static_cast<int>(cupsLastError());
     return false;
   }
 
   for (int printer_index = 0; printer_index < num_dests; ++printer_index) {
     const cups_dest_t& printer = destinations[printer_index];
 
     // CUPS can have 'printers' that are actually scanners. (not MFC)
     // At least on Mac. Check for scanners and skip them.
     const char* type_str = cupsGetOption(kCUPSPrinterTypeOpt,
         printer.num_options, printer.options);
-    if (type_str != NULL) {
+    if (type_str) {
       int type;
       if (base::StringToInt(type_str, &type) && (type & CUPS_PRINTER_SCANNER))
         continue;
     }
 
     PrinterBasicInfo printer_info;
     printer_info.printer_name = printer.name;
     printer_info.is_default = printer.is_default;
 
     const char* info = cupsGetOption(kCUPSPrinterInfoOpt,
         printer.num_options, printer.options);
-    if (info != NULL)
+    if (info)
       printer_info.printer_description = info;
 
     const char* state = cupsGetOption(kCUPSPrinterStateOpt,
         printer.num_options, printer.options);
-    if (state != NULL)
+    if (state)
       base::StringToInt(state, &printer_info.printer_status);
 
     const char* drv_info = cupsGetOption(kCUPSPrinterMakeModelOpt,
                                          printer.num_options,
                                          printer.options);
     if (drv_info)
       printer_info.options[kDriverInfoTagName] = *drv_info;
 
     // Store printer options.
     for (int opt_index = 0; opt_index < printer.num_options; ++opt_index) {
       printer_info.options[printer.options[opt_index].name] =
           printer.options[opt_index].value;
     }
 
     printer_list->push_back(printer_info);
   }
 
   cupsFreeDests(num_dests, destinations);
 
-  VLOG(1) << "CUPS: Enumerated printers"
-          << ", server: " << print_server_url_
+  VLOG(1) << "CUPS: Enumerated printers, server: " << print_server_url_
           << ", # of printers: " << printer_list->size();
   return true;
 }
 
 std::string PrintBackendCUPS::GetDefaultPrinterName() {
   // Not using cupsGetDefault() because it lies about the default printer.
   cups_dest_t* dests;
   int num_dests = GetDests(&dests);
-  cups_dest_t* dest = cupsGetDest(NULL, NULL, num_dests, dests);
+  cups_dest_t* dest = cupsGetDest(nullptr, nullptr, num_dests, dests);
   std::string name = dest ? std::string(dest->name) : std::string();
   cupsFreeDests(num_dests, dests);
   return name;
 }
 
 bool PrintBackendCUPS::GetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name,
     PrinterSemanticCapsAndDefaults* printer_info) {
   PrinterCapsAndDefaults info;
   if (!GetPrinterCapsAndDefaults(printer_name, &info) )
     return false;
 
   return ParsePpdCapabilities(
       printer_name, info.printer_capabilities, printer_info);
 }
 
 bool PrintBackendCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
     PrinterCapsAndDefaults* printer_info) {
   DCHECK(printer_info);
 
-  VLOG(1) << "CUPS: Getting caps and defaults"
-          << ", printer name: " << printer_name;
+  VLOG(1) << "CUPS: Getting caps and defaults, printer name: " << printer_name;
 
   base::FilePath ppd_path(GetPPD(printer_name.c_str()));
   // In some cases CUPS failed to get ppd file.
   if (ppd_path.empty()) {
     LOG(ERROR) << "CUPS: Failed to get PPD, printer name: " << printer_name;
     return false;
   }
 
   std::string content;
   bool res = base::ReadFileToString(ppd_path, &content);
 
   base::DeleteFile(ppd_path, false);
 
   if (res) {
     printer_info->printer_capabilities.swap(content);
     printer_info->caps_mime_type = "application/pagemaker";
     // In CUPS, printer defaults is a part of PPD file. Nothing to upload here.
     printer_info->printer_defaults.clear();
     printer_info->defaults_mime_type.clear();
   }
 
   return res;
 }
 
 std::string PrintBackendCUPS::GetPrinterDriverInfo(
     const std::string& printer_name) {
-  cups_dest_t* destinations = NULL;
-  int num_dests = GetDests(&destinations);
   std::string result;
-  for (int printer_index = 0; printer_index < num_dests; ++printer_index) {
-    const cups_dest_t& printer = destinations[printer_index];
-    if (printer_name == printer.name) {
-      const char* info = cupsGetOption(kCUPSPrinterMakeModelOpt,
-                                       printer.num_options,
-                                       printer.options);
-      if (info)
-        result = *info;
-    }
-  }
 
-  cupsFreeDests(num_dests, destinations);
+  cups_dest_t* dest = GetNamedDest(printer_name);
+  if (!dest)
+    return result;
+
+  DCHECK_EQ(printer_name, dest->name);
+  const char* info =
+      cupsGetOption(kCUPSPrinterMakeModelOpt, dest->num_options, dest->options);
+  if (info)
+    result = *info;
+  cupsFreeDests(1, dest);
   return result;
 }
 
 bool PrintBackendCUPS::IsValidPrinter(const std::string& printer_name) {
-  // This is not very efficient way to get specific printer info. CUPS 1.4
-  // supports cupsGetNamedDest() function. However, CUPS 1.4 is not available
-  // everywhere (for example, it supported from Mac OS 10.6 only).
-  PrinterList printer_list;
-  EnumeratePrinters(&printer_list);
+  cups_dest_t* dest = GetNamedDest(printer_name);
+  if (!dest)
+    return false;
 
-  PrinterList::iterator it;
-  for (it = printer_list.begin(); it != printer_list.end(); ++it)
-    if (it->printer_name == printer_name)
-      return true;
-  return false;
+  cupsFreeDests(1, dest);
+  return true;
 }
 
 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
     const base::DictionaryValue* print_backend_settings) {
   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);
 
@@ skipping 23 matching lines @@
     return cupsGetDests2(http.http(), dests);
   }
 }
 
 base::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);
   base::FilePath ppd_path;
-  const char* ppd_file_path = NULL;
+  const char* ppd_file_path = nullptr;
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     ppd_file_path = cupsGetPPD(name);
     if (ppd_file_path)
       ppd_path = base::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
@@ skipping 11 matching lines @@
       // http->data_remaining or http->_data_remaining, unfortunately http_t
       // is an internal structure and fields are not exposed in CUPS headers.
       // httpGetLength or httpGetLength2 returning the full content size.
       // Comparing file size against that content length might be unreliable
       // since some http reponses are encoded and content_length > file size.
       // Let's just check for the obvious CUPS and http errors here.
       ppd_path = base::FilePath(ppd_file_path);
       ipp_status_t error_code = cupsLastError();
       int http_error = httpError(http.http());
       if (error_code > IPP_OK_EVENTS_COMPLETE || http_error != 0) {
-        LOG(ERROR) << "Error downloading PPD file"
-                   << ", name: " << name
+        LOG(ERROR) << "Error downloading PPD file, name: " << name
                    << ", CUPS error: " << static_cast<int>(error_code)
                    << ", HTTP error: " << http_error;
         base::DeleteFile(ppd_path, false);
         ppd_path.clear();
       }
     }
   }
   return ppd_path;
 }
 
+cups_dest_t* PrintBackendCUPS::GetNamedDest(const std::string& printer_name) {
+  // Use default (local) print server.
+  if (print_server_url_.is_empty())
+    return cupsGetNamedDest(CUPS_HTTP_DEFAULT, printer_name.c_str(), nullptr);
+
+  HttpConnectionCUPS http(print_server_url_, cups_encryption_);
+  http.SetBlocking(blocking_);
+  return cupsGetNamedDest(http.http(), printer_name.c_str(), nullptr);
+}
+
 }  // namespace printing