Print Preview: Get printer info with capabilities.

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>
 
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 #include "printing/backend/cups_helper.h"
 #include "printing/backend/print_backend_consts.h"
 #include "url/gurl.h"
 
 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";
+namespace {
+
+const char kCUPSPrinterInfoOpt[] = "printer-info";
+const char kCUPSPrinterStateOpt[] = "printer-state";
+const char kCUPSPrinterTypeOpt[] = "printer-type";
+const char kCUPSPrinterMakeModelOpt[] = "printer-make-and-model";
+
+bool PrinterBasicInfoFromCUPS(const cups_dest_t& printer,
+                              PrinterBasicInfo* printer_info) {
+  // 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) {
+    int type;
+    if (base::StringToInt(type_str, &type) && (type & CUPS_PRINTER_SCANNER))
+      return false;
+  }
+
+  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)
+    printer_info->printer_description = info;
+
+  const char* state =
+      cupsGetOption(kCUPSPrinterStateOpt, printer.num_options, printer.options);
+  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;
+  }
+  return true;
+}
+
+}  // namespace
 
 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 GetPrinterBasicInfo(const std::string& printer_name,
+                           PrinterBasicInfo* printer_info) 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;
 
   // The following functions are wrappers around corresponding CUPS functions.
   // <functions>2() are called when print server is specified, and plain version
@@ skipping 28 matching lines @@
   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) {
-      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)
-      printer_info.printer_description = info;
-
-    const char* state = cupsGetOption(kCUPSPrinterStateOpt,
-        printer.num_options, printer.options);
-    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);
+    if (PrinterBasicInfoFromCUPS(printer, &printer_info))
+      printer_list->push_back(printer_info);
   }
 
   cupsFreeDests(num_dests, destinations);
 
   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(nullptr, nullptr, num_dests, dests);
   std::string name = dest ? std::string(dest->name) : std::string();
   cupsFreeDests(num_dests, dests);
   return name;
 }
 
+bool PrintBackendCUPS::GetPrinterBasicInfo(const std::string& printer_name,
+                                           PrinterBasicInfo* printer_info) {
+  cups_dest_t* dest = GetNamedDest(printer_name);
+  if (!dest)
+    return false;
+
+  DCHECK_EQ(printer_name, dest->name);
+  bool ret = PrinterBasicInfoFromCUPS(*dest, printer_info);
+  cupsFreeDests(1, dest);
+  return ret;
+}
+
 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);
 }
@@ skipping 142 matching lines @@
   // 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