Added a diagnostic user message when enumerating printers fails. Also tweaked...

chrome/service/cloud_print/print_system_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 "chrome/service/cloud_print/print_system.h"
 
 #include <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 10 matching lines @@
 #include "base/rand_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "googleurl/src/gurl.h"
+#include "grit/generated_resources.h"
 #include "printing/backend/cups_helper.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/print_backend_consts.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace {
 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 static const char kCUPSPrinterStateOpt[] = "printer-state";
 static const char kCUPSPrintServerURLs[] = "print_server_urls";
 static const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
 
 // Default port for IPP print servers.
 static const int kDefaultIPPServerPort = 631;
 
@@ skipping 22 matching lines @@
   CapsMap caps_cache;
 };
 
 class PrintSystemCUPS : public PrintSystem {
  public:
   explicit PrintSystemCUPS(const DictionaryValue* print_system_settings);
 
   // PrintSystem implementation.
   virtual PrintSystemResult Init();
 
-  virtual void EnumeratePrinters(printing::PrinterList* printer_list);
+  virtual PrintSystem::PrintSystemResult EnumeratePrinters(
+      printing::PrinterList* printer_list);
 
   virtual void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
       PrinterCapsAndDefaultsCallback* callback);
 
   virtual bool IsValidPrinter(const std::string& printer_name);
 
   virtual bool ValidatePrintTicket(const std::string& printer_name,
                                    const std::string& print_ticket_data);
 
@@ skipping 57 matching lines @@
       const std::string& printer_name,
       const printing::PrinterCapsAndDefaults& printer_info);
 
   // PrintServerList contains information about all print servers and backends
   // this proxy is connected to.
   typedef std::list<PrintServerInfoCUPS> PrintServerList;
   PrintServerList print_servers_;
 
   int update_timeout_;
   bool initialized_;
+  bool printer_enum_succeeded_;
 };
 
 class PrintServerWatcherCUPS
   : public PrintSystem::PrintServerWatcher {
  public:
   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system),
         delegate_(NULL) {
   }
   ~PrintServerWatcherCUPS() {
@@ skipping 187 matching lines @@
       delegate->OnJobSpoolSucceeded(job_id);
     else
       delegate->OnJobSpoolFailed();
   }
  private:
   scoped_refptr<PrintSystemCUPS> print_system_;
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
-    : update_timeout_(kCheckForPrinterUpdatesMs), initialized_(false) {
+    : update_timeout_(kCheckForPrinterUpdatesMs),
+      initialized_(false),
+      printer_enum_succeeded_(false) {
   if (print_system_settings) {
     int timeout;
     if (print_system_settings->GetInteger(kCUPSUpdateTimeoutMs, &timeout))
       update_timeout_ = timeout;
   }
 
   InitPrintBackends(print_system_settings);
 }
 
 void PrintSystemCUPS::InitPrintBackends(
@@ skipping 33 matching lines @@
 }
 
 PrintSystem::PrintSystemResult PrintSystemCUPS::Init() {
   UpdatePrinters();
   initialized_ = true;
   return PrintSystemResult(true, std::string());
 }
 
 void PrintSystemCUPS::UpdatePrinters() {
   PrintServerList::iterator it;
+  printer_enum_succeeded_ = true;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
-    it->backend->EnumeratePrinters(&it->printers);
+    if (!it->backend->EnumeratePrinters(&it->printers))
+      printer_enum_succeeded_ = false;
     it->caps_cache.clear();
     printing::PrinterList::iterator printer_it;
     for (printer_it = it->printers.begin();
         printer_it != it->printers.end(); ++printer_it) {
       printer_it->printer_name = MakeFullPrinterName(it->url,
                                                      printer_it->printer_name);
     }
     VLOG(1) << "CUPS: Updated printer list for url: " << it->url
             << " Number of printers: " << it->printers.size();
   }
 
   // Schedule next update.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       NewRunnableMethod(this, &PrintSystemCUPS::UpdatePrinters),
       GetUpdateTimeoutMs());
 }
 
-void PrintSystemCUPS::EnumeratePrinters(printing::PrinterList* printer_list) {
+PrintSystem::PrintSystemResult PrintSystemCUPS::EnumeratePrinters(
+    printing::PrinterList* printer_list) {
   DCHECK(initialized_);
   printer_list->clear();
   PrintServerList::iterator it;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     printer_list->insert(printer_list->end(),
         it->printers.begin(), it->printers.end());
   }
   VLOG(1) << "CUPS: Total " << printer_list->size() << " printers enumerated.";
+  // TODO(sanjeevr): Maybe some day we want to report the actual server names
+  // for which the enumeration failed.
+  return PrintSystemResult(printer_enum_succeeded_, std::string());
 }
 
 void PrintSystemCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
     PrinterCapsAndDefaultsCallback* callback) {
   printing::PrinterCapsAndDefaults printer_info;
   bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableFunction(&PrintSystemCUPS::RunCapsCallback,
@@ skipping 313 matching lines @@
 void PrintSystemCUPS::RunCapsCallback(
     PrinterCapsAndDefaultsCallback* callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback->Run(succeeded, printer_name, printer_info);
   delete callback;
 }
 
 }  // namespace cloud_print