ScopedPrinterInfoSetter on crash prone blocks.

chrome/service/cloud_print/print_system_win.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 <objidl.h>
 #include <winspool.h>
 #include <xpsprint.h>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/object_watcher.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_hdc.h"
+#include "chrome/common/child_process_logging.h"
 #include "chrome/service/service_process.h"
 #include "chrome/service/service_utility_process_host.h"
 #include "grit/generated_resources.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/print_backend_consts.h"
 #include "printing/backend/win_helper.h"
 #include "printing/emf_win.h"
 #include "printing/page_range.h"
 #include "printing/pdf_render_settings.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 125 matching lines @@
   class Delegate {
    public:
     virtual ~Delegate() {}
     virtual void OnPrinterAdded() = 0;
     virtual void OnPrinterDeleted() = 0;
     virtual void OnPrinterChanged() = 0;
     virtual void OnJobChanged() = 0;
   };
 
   bool Start(const std::string& printer_name, Delegate* delegate) {
+    scoped_refptr<printing::PrintBackend> print_backend(
+        printing::PrintBackend::CreateInstance(NULL));
+    printer_info_ = print_backend->GetPrinterDriverInfo(printer_name);
+    child_process_logging::ScopedPrinterInfoSetter prn_info(printer_info_);
+
     delegate_ = delegate;
     // An empty printer name means watch the current server, we need to pass
     // NULL to OpenPrinter.
     LPTSTR printer_name_to_use = NULL;
     std::wstring printer_name_wide;
     if (!printer_name.empty()) {
       printer_name_wide = UTF8ToWide(printer_name);
       printer_name_to_use = const_cast<LPTSTR>(printer_name_wide.c_str());
     }
     bool ret = false;
@@ skipping 12 matching lines @@
   }
   bool Stop() {
     watcher_.StopWatching();
     printer_.Close();
     printer_change_.Close();
     return true;
   }
 
   // base::ObjectWatcher::Delegate method
   virtual void OnObjectSignaled(HANDLE object) {
+    child_process_logging::ScopedPrinterInfoSetter prn_info(printer_info_);
     DWORD change = 0;
     FindNextPrinterChangeNotification(object, &change, NULL, NULL);
 
     if (change != ((PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB) &
                   (~PRINTER_CHANGE_FAILED_CONNECTION_PRINTER))) {
       // For printer connections, we get spurious change notifications with
       // all flags set except PRINTER_CHANGE_FAILED_CONNECTION_PRINTER.
       // Ignore these.
       if (change & PRINTER_CHANGE_ADD_PRINTER) {
         delegate_->OnPrinterAdded();
@@ skipping 40 matching lines @@
     return ret;
   }
 
  private:
   base::win::ObjectWatcher watcher_;
   printing::ScopedPrinterHandle printer_;  // The printer being watched
   // Returned by FindFirstPrinterChangeNotifier.
   ScopedPrinterChangeHandle printer_change_;
   Delegate* delegate_;           // Delegate to notify
   bool did_signal_;              // DoneWaiting was called
+  std::string printer_info_;     // For crash reporting.
 };
 
 // This typedef is to workaround the issue with certain versions of
 // Visual Studio where it gets confused between multiple Delegate.
 // In this case, some compilers get confused and inherit
 // PrintSystemWin watchers from wrong Delegate, giving C2664 and C2259 errors.
 typedef PrintSystemWatcherWin::Delegate PrintSystemWatcherWinDelegate;
 
 class PrintSystemWin : public PrintSystem {
  public:
@@ skipping 103 matching lines @@
 
     // PrintSystem::JobSpooler implementation.
     virtual bool Spool(const std::string& print_ticket,
                        const FilePath& print_data_file_path,
                        const std::string& print_data_mime_type,
                        const std::string& printer_name,
                        const std::string& job_title,
                        const std::vector<std::string>& tags,
                        JobSpooler::Delegate* delegate) OVERRIDE {
       // TODO(gene): add tags handling.
+      scoped_refptr<printing::PrintBackend> print_backend(
+          printing::PrintBackend::CreateInstance(NULL));
+      child_process_logging::ScopedPrinterInfoSetter prn_info(
+          print_backend->GetPrinterDriverInfo(printer_name));
       return core_->Spool(print_ticket, print_data_file_path,
                           print_data_mime_type, printer_name, job_title,
                           delegate);
     }
 
    private:
     // We use a Core class because we want a separate RefCountedThreadSafe
     // implementation for ServiceUtilityProcessHost::Client.
     class Core : public ServiceUtilityProcessHost::Client,
                  public base::win::ObjectWatcher::Delegate {
      public:
       Core()
           : last_page_printed_(-1),
             job_id_(-1),
             delegate_(NULL),
             saved_dc_(0),
             should_couninit_(false) {
       }
 
       ~Core() {}
 
       bool Spool(const std::string& print_ticket,
                  const FilePath& print_data_file_path,
                  const std::string& print_data_mime_type,
                  const std::string& printer_name,
                  const std::string& job_title,
                  JobSpooler::Delegate* delegate) {
+        scoped_refptr<printing::PrintBackend> print_backend(
+            printing::PrintBackend::CreateInstance(NULL));
+        child_process_logging::ScopedPrinterInfoSetter prn_info(
+            print_backend->GetPrinterDriverInfo(printer_name));
         if (delegate_) {
           // We are already in the process of printing.
           NOTREACHED();
           return false;
         }
         last_page_printed_ = -1;
         // We only support PDF and XPS documents for now.
         if (print_data_mime_type == "application/pdf") {
           DevMode pt_dev_mode;
           HRESULT hr = PrintTicketToDevMode(printer_name, print_ticket,
@@ skipping 356 matching lines @@
   handler->Start();
 }
 
 bool PrintSystemWin::IsValidPrinter(const std::string& printer_name) {
   return print_backend_->IsValidPrinter(printer_name);
 }
 
 bool PrintSystemWin::ValidatePrintTicket(
     const std::string& printer_name,
     const std::string& print_ticket_data) {
+  child_process_logging::ScopedPrinterInfoSetter prn_info(
+      print_backend_->GetPrinterDriverInfo(printer_name));
   printing::ScopedXPSInitializer xps_initializer;
   if (!xps_initializer.initialized()) {
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return false;
   }
   bool ret = false;
   HPTPROVIDER provider = NULL;
   printing::XPSModule::OpenProvider(UTF8ToWide(printer_name.c_str()),
                                     1,
                                     &provider);
@@ skipping 19 matching lines @@
         result_ticket_stream.get(),
         error.Receive()));
     printing::XPSModule::CloseProvider(provider);
   }
   return ret;
 }
 
 bool PrintSystemWin::GetJobDetails(const std::string& printer_name,
                                    PlatformJobId job_id,
                                    PrintJobDetails *job_details) {
+  child_process_logging::ScopedPrinterInfoSetter prn_info(
+      print_backend_->GetPrinterDriverInfo(printer_name));
   DCHECK(job_details);
   printing::ScopedPrinterHandle printer_handle;
   std::wstring printer_name_wide = UTF8ToWide(printer_name);
   OpenPrinter(const_cast<LPTSTR>(printer_name_wide.c_str()),
               printer_handle.Receive(), NULL);
   DCHECK(printer_handle.IsValid());
   bool ret = false;
   if (printer_handle.IsValid()) {
     DWORD bytes_needed = 0;
     GetJob(printer_handle, job_id, 1, NULL, 0, &bytes_needed);
@@ skipping 63 matching lines @@
   RpcStringFree(reinterpret_cast<RPC_WSTR *>(&proxy_id_as_string));
   return ret;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print