CUPS printing: Do not add scanners to the printer list.

printing/backend/print_backend_cups.cc

 // Copyright (c) 2011 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 <pthread.h>
+
+#if defined(OS_MACOSX)

[Mark Mentovai, 2011/08/08 22:11:05]

The chain that you’re using to pick up this definition is pretty weak. Add your
own #include for "build/build_config.h"?

[Lei Zhang, 2011/08/08 22:28:08]

Done.

+#include <AvailabilityMacros.h>
+#else
 #include <gcrypt.h>
 #endif
-#include <pthread.h>
 
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/lock.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)
+#if defined(OS_MACOSX)
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5
+const int CUPS_PRINTER_SCANNER = 0x2000000;  // Scanner-only device
+#endif  // MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5
+#else
 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.
 // Google search for 'gnutls thread safety' provided a solution that
 // initialized gcrypt and gnutls.
@@ skipping 29 matching lines @@
     }
     if ((*pgnutls_global_init)() != 0)
       LOG(ERROR) << "Gnutls initialization failed";
   }
 };
 
 static base::LazyInstance<GcryptInitializer> g_gcrypt_initializer(
     base::LINKER_INITIALIZED);
 
 }  // namespace
-#endif
+#endif  // defined(OS_MACOSX)
 
 namespace printing {
 
 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 static const char kCUPSPrinterStateOpt[] = "printer-state";
+static const char kCUPSPrinterTypeOpt[] = "printer-type";
 
 class PrintBackendCUPS : public PrintBackend {
  public:
   PrintBackendCUPS(const GURL& print_server_url, bool blocking);
   virtual ~PrintBackendCUPS() {}
 
   // PrintBackend implementation.
   virtual bool EnumeratePrinters(PrinterList* printer_list);
 
   virtual std::string GetDefaultPrinterName();
@@ skipping 29 matching lines @@
     VLOG(1) << "CP_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) {
+      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)
       printer_info.printer_description = info;
 
     const char* state = cupsGetOption(kCUPSPrinterStateOpt,
@@ skipping 139 matching lines @@
                    << ", HTTP error: " << http_error;
         file_util::Delete(ppd_path, false);
         ppd_path.clear();
       }
     }
   }
   return ppd_path;
 }
 
 }  // namespace printing