Set the printer info in crash reports using the crash key logging system.

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_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/object_watcher.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_hdc.h"
-#include "chrome/common/child_process_logging.h"
+#include "chrome/common/crash_keys.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 131 matching lines @@
     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_);
+    crash_keys::ScopedPrinterInfo crash_key(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());
     }
@@ 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_);
+    crash_keys::ScopedPrinterInfo crash_key(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 146 matching lines @@
     virtual bool Spool(const std::string& print_ticket,
                        const base::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(
+      crash_keys::ScopedPrinterInfo crash_key(
           print_backend->GetPrinterDriverInfo(printer_name));
       return core_->Spool(print_ticket, print_data_file_path,
                           print_data_mime_type, printer_name, job_title,
                           delegate);
     }
 
    protected:
     virtual ~JobSpoolerWin() {}
 
    private:
@@ skipping 12 matching lines @@
       ~Core() {}
 
       bool Spool(const std::string& print_ticket,
                  const base::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(
+        crash_keys::ScopedPrinterInfo crash_key(
             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;
@@ skipping 368 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(
+  crash_keys::ScopedPrinterInfo crash_key(
       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,
@@ skipping 20 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(
+  crash_keys::ScopedPrinterInfo crash_key(
       print_backend_->GetPrinterDriverInfo(printer_name));
   DCHECK(job_details);
   printing::ScopedPrinterHandle printer_handle;
   std::wstring printer_name_wide = UTF8ToWide(printer_name);
   printer_handle.OpenPrinter(printer_name_wide.c_str());
   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 50 matching lines @@
   return "application/pdf";
 }
 
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print