ScopedPrinterInfoSetter on crash prone blocks.

chrome/service/cloud_print/print_system_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 "chrome/service/cloud_print/print_system.h"
 
 #include <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 222 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherCUPS);
 };
 
 class PrinterWatcherCUPS
     : public PrintSystem::PrinterWatcher {
  public:
   PrinterWatcherCUPS(PrintSystemCUPS* print_system,
                      const std::string& printer_name)
       : printer_name_(printer_name),
-    delegate_(NULL),
-    print_system_(print_system) {
+      delegate_(NULL),

[Albert Bodenhamer, 2012/03/13 23:57:39]

why is this changed?

[Vitaly Buka (NO REVIEWS), 2012/03/14 00:11:20]

It was attempt to fix style, but still incorrectly.
Now it's fixed.
On 2012/03/13 23:57:39, Albert Bodenhamer wrote:

+      print_system_(print_system) {
   }
 
   ~PrinterWatcherCUPS() {
     StopWatching();
   }
 
   // PrintSystem::PrinterWatcher implementation.
   virtual bool StartWatching(
       PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE{
+    scoped_refptr<printing::PrintBackend> print_backend(
+        printing::PrintBackend::CreateInstance(NULL));
+    child_process_logging::ScopedPrinterInfoSetter prn_info(
+        print_backend->GetPrinterDriverInfo(printer_name));
     if (delegate_ != NULL)
       StopWatching();
     delegate_ = delegate;
     settings_hash_ = GetSettingsHash();
     // Schedule next job status update.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
         base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
     // Schedule next printer check.
     // TODO(gene): Randomize time for the next printer update.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeout());
     return true;
   }
 
   virtual bool StopWatching() OVERRIDE{
     delegate_ = NULL;
     return true;
   }
 
   bool GetCurrentPrinterInfo(printing::PrinterBasicInfo* printer_info) {
     DCHECK(printer_info);
     return print_system_->GetPrinterInfo(printer_name_, printer_info);
   }
 
-  void JobStatusUpdate() {
-    if (delegate_ == NULL)
-      return;  // Orphan call. We have been stopped already.
-    // For CUPS proxy, we are going to fire OnJobChanged notification
-    // periodically. Higher level will check if there are any outstanding
-    // jobs for this printer and check their status. If printer has no
-    // outstanding jobs, OnJobChanged() will do nothing.
-    delegate_->OnJobChanged();
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
-        base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
-  }
-
-  void PrinterUpdate() {
-    if (delegate_ == NULL)
-      return;  // Orphan call. We have been stopped already.
-    VLOG(1) << "CP_CUPS: Checking for printer updates: " << printer_name_;
-    if (print_system_->NotifyDelete() &&
-        !print_system_->IsValidPrinter(printer_name_)) {
-      delegate_->OnPrinterDeleted();
-      VLOG(1) << "CP_CUPS: Printer deleted: " << printer_name_;
-    } else {
-      std::string new_hash = GetSettingsHash();
-      if (settings_hash_ != new_hash) {
-        settings_hash_ = new_hash;
-        delegate_->OnPrinterChanged();
-        VLOG(1) << "CP_CUPS: Printer update detected for: " << printer_name_;
-      }
-    }
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
-        print_system_->GetUpdateTimeout());
-  }
-
  private:
   std::string GetSettingsHash() {
     printing::PrinterBasicInfo info;
     if (!print_system_->GetPrinterInfo(printer_name_, &info))
       return std::string();
 
     printing::PrinterCapsAndDefaults caps;
     if (!print_system_->GetPrinterCapsAndDefaults(printer_name_, &caps))
       return std::string();
 
     std::string to_hash(info.printer_name);
     to_hash += info.printer_description;
     std::map<std::string, std::string>::const_iterator it;
     for (it = info.options.begin(); it != info.options.end(); ++it) {
       to_hash += it->first;
       to_hash += it->second;
     }
 
     to_hash += caps.printer_capabilities;
     to_hash += caps.caps_mime_type;
     to_hash += caps.printer_defaults;
     to_hash += caps.defaults_mime_type;
 
     return base::MD5String(to_hash);
   }
-
   std::string printer_name_;
   PrintSystem::PrinterWatcher::Delegate* delegate_;
   scoped_refptr<PrintSystemCUPS> print_system_;
   std::string settings_hash_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterWatcherCUPS);
 };
 
 class JobSpoolerCUPS : public PrintSystem::JobSpooler {
  public:
@@ skipping 151 matching lines @@
 
 bool PrintSystemCUPS::ValidatePrintTicket(const std::string& printer_name,
                                         const std::string& print_ticket_data) {
   DCHECK(initialized_);
   scoped_ptr<Value> ticket_value(base::JSONReader::Read(print_ticket_data,
       false));
   return ticket_value != NULL && ticket_value->IsType(Value::TYPE_DICTIONARY);
 }
 
 // Print ticket on linux is a JSON string containing only one dictionary.
-bool PrintSystemCUPS::ParsePrintTicket(const std::string& print_ticket,
-                                  std::map<std::string, std::string>* options) {
+bool PrintSystemCUPS::ParsePrintTicket(
+    const std::string& print_ticket,
+    std::map<std::string, std::string>* options) {
   DCHECK(options);
   scoped_ptr<Value> ticket_value(base::JSONReader::Read(print_ticket, false));
   if (ticket_value == NULL || !ticket_value->IsType(Value::TYPE_DICTIONARY))
     return false;
 
   options->clear();
   DictionaryValue* ticket_dict =
       static_cast<DictionaryValue*>(ticket_value.get());
   DictionaryValue::key_iterator it(ticket_dict->begin_keys());
   for (; it != ticket_dict->end_keys(); ++it) {
@@ skipping 18 matching lines @@
     return false;
 
   PrintServerInfoCUPS::CapsMap::iterator caps_it =
       server_info->caps_cache.find(printer_name);
   if (caps_it != server_info->caps_cache.end()) {
     *printer_info = caps_it->second;
     return true;
   }
 
   // TODO(gene): Retry multiple times in case of error.
+  child_process_logging::ScopedPrinterInfoSetter prn_info(server_info->backend->GetPrinterDriverInfo());

[Albert Bodenhamer, 2012/03/13 23:57:39]

80 chars

[Vitaly Buka (NO REVIEWS), 2012/03/14 00:11:20]

Done.

   if (!server_info->backend->GetPrinterCapsAndDefaults(short_printer_name,
                                                        printer_info) ) {
     return false;
   }
 
   server_info->caps_cache[printer_name] = *printer_info;
   return true;
 }
 
 bool PrintSystemCUPS::GetJobDetails(const std::string& printer_name,
                                     PlatformJobId job_id,
                                     PrintJobDetails *job_details) {
   DCHECK(initialized_);
   DCHECK(job_details);
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
+  child_process_logging::ScopedPrinterInfoSetter prn_info(
+      server_info->backend->GetPrinterDriverInfo());
   cups_job_t* jobs = NULL;
   int num_jobs = GetJobs(&jobs, server_info->url,
                          short_printer_name.c_str(), 1, -1);
   bool error = (num_jobs == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE);
   if (error) {
     VLOG(1) << "CP_CUPS: Error getting jobs from CUPS server. Printer:"
             << printer_name
             << " Error: "
             << static_cast<int>(cupsLastError());
     return false;
@@ skipping 145 matching lines @@
     bool* dry_run) {
   DCHECK(initialized_);
   VLOG(1) << "CP_CUPS: Spooling print job for: " << printer_name;
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
+  child_process_logging::ScopedPrinterInfoSetter prn_info(
+      server_info->backend->GetPrinterDriverInfo(printer_name));
+
   // We need to store options as char* string for the duration of the
   // cupsPrintFile2 call. We'll use map here to store options, since
   // Dictionary value from JSON parser returns wchat_t.
   std::map<std::string, std::string> options;
   bool res = ParsePrintTicket(print_ticket, &options);
   DCHECK(res);  // If print ticket is invalid we still print using defaults.
 
   // Check if this is a dry run (test) job.
   *dry_run = CloudPrintHelpers::IsDryRunJob(tags);
   if (*dry_run) {
@@ skipping 67 matching lines @@
 
 void PrintSystemCUPS::RunCapsCallback(
     const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print