Improved resource management

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>
 
@@ skipping 15 matching lines @@
 #include "printing/emf_win.h"
 #include "printing/page_range.h"
 #include "printing/pdf_render_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 
 #pragma comment(lib, "rpcrt4.lib")  // for UuidToString & Co.
 
 namespace {
 
+class PrinterChangeHandleTraits {
+ public:
+  static bool CloseHandle(HANDLE handle) {
+    return ::FindClosePrinterChangeNotification(handle) != FALSE;
+  }
+};
+
+typedef base::win::GenericScopedHandle<PrinterChangeHandleTraits>
+    ScopedPrinterChangeHandle;
+
 class DevMode {
  public:
   DevMode() : dm_(NULL) {}
   ~DevMode() { Free(); }
 
   void Allocate(int size) {
     Free();
     dm_ = reinterpret_cast<DEVMODE*>(new char[size]);
   }
 
@@ skipping 69 matching lines @@
   return hr;
 }
 
 }  // namespace
 
 namespace cloud_print {
 
 class PrintSystemWatcherWin : public base::win::ObjectWatcher::Delegate {
  public:
   PrintSystemWatcherWin()
-      : printer_(NULL),
-        printer_change_(NULL),
-        delegate_(NULL),
+      : delegate_(NULL),
         did_signal_(false) {
   }
   ~PrintSystemWatcherWin() {
     Stop();
   }
 
   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) {
     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;
-    OpenPrinter(printer_name_to_use, &printer_, NULL);
-    if (printer_) {
-      printer_change_ = FindFirstPrinterChangeNotification(
-          printer_, PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB, 0, NULL);
-      if (printer_change_) {
+    OpenPrinter(printer_name_to_use, printer_.Receive(), NULL);
+    if (printer_.IsValid()) {
+      printer_change_.Set(FindFirstPrinterChangeNotification(
+          printer_, PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB, 0, NULL));
+      if (printer_change_.IsValid()) {
         ret = watcher_.StartWatching(printer_change_, this);
       }
     }
     if (!ret) {
       Stop();
     }
     return ret;
   }
   bool Stop() {
     watcher_.StopWatching();
-    if (printer_) {
-      ClosePrinter(printer_);
-      printer_ = NULL;
-    }
-    if (printer_change_) {
-      FindClosePrinterChangeNotification(printer_change_);
-      printer_change_ = NULL;
-    }
+    printer_.Close();
+    printer_change_.Close();
     return true;
   }
 
   // base::ObjectWatcher::Delegate method
   virtual void OnObjectSignaled(HANDLE object) {
     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();
       } else if (change & PRINTER_CHANGE_DELETE_PRINTER) {
         delegate_->OnPrinterDeleted();
       } else if (change & PRINTER_CHANGE_SET_PRINTER) {
         delegate_->OnPrinterChanged();
       }
       if (change & PRINTER_CHANGE_JOB) {
         delegate_->OnJobChanged();
       }
     }
     watcher_.StartWatching(printer_change_, this);
   }
 
   bool GetCurrentPrinterInfo(printing::PrinterBasicInfo* printer_info) {
     DCHECK(printer_info);
-    if (!printer_)
+    if (!printer_.IsValid())
       return false;
 
     DWORD bytes_needed = 0;
     bool ret = false;
     GetPrinter(printer_, 2, NULL, 0, &bytes_needed);
     if (0 != bytes_needed) {
       scoped_array<BYTE> printer_info_buffer(new BYTE[bytes_needed]);
       if (GetPrinter(printer_, 2, printer_info_buffer.get(),
                      bytes_needed, &bytes_needed)) {
         PRINTER_INFO_2* printer_info_win =
@@ skipping 10 matching lines @@
               WideToUTF8(printer_info_win->pDriverName);
         printer_info->printer_status = printer_info_win->Status;
         ret = true;
       }
     }
     return ret;
   }
 
  private:
   base::win::ObjectWatcher watcher_;
-  HANDLE printer_;            // The printer being watched
-  HANDLE printer_change_;     // Returned by FindFirstPrinterChangeNotifier
-  Delegate* delegate_;        // Delegate to notify
-  bool did_signal_;           // DoneWaiting was called
+  printing::ScopedPrinterHandle printer_;  // The printer being watched
+  // Returned by FindFirstPrinterChangeNotifier.
+  ScopedPrinterChangeHandle printer_change_;
+  Delegate* delegate_;           // Delegate to notify
+  bool did_signal_;              // DoneWaiting was called
 };
 
 // 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 546 matching lines @@
         error.Receive()));
     printing::XPSModule::CloseProvider(provider);
   }
   return ret;
 }
 
 bool PrintSystemWin::GetJobDetails(const std::string& printer_name,
                                    PlatformJobId job_id,
                                    PrintJobDetails *job_details) {
   DCHECK(job_details);
-  HANDLE printer_handle = NULL;
+  printing::ScopedPrinterHandle printer_handle;
   std::wstring printer_name_wide = UTF8ToWide(printer_name);
-  OpenPrinter(const_cast<LPTSTR>(printer_name_wide.c_str()), &printer_handle,
-              NULL);
-  DCHECK(printer_handle);
+  OpenPrinter(const_cast<LPTSTR>(printer_name_wide.c_str()),
+              printer_handle.Receive(), NULL);
+  DCHECK(printer_handle.IsValid());
   bool ret = false;
-  if (printer_handle) {
+  if (printer_handle.IsValid()) {
     DWORD bytes_needed = 0;
     GetJob(printer_handle, job_id, 1, NULL, 0, &bytes_needed);
     DWORD last_error = GetLastError();
     if (ERROR_INVALID_PARAMETER != last_error) {
       // ERROR_INVALID_PARAMETER normally means that the job id is not valid.
       DCHECK(last_error == ERROR_INSUFFICIENT_BUFFER);
       scoped_array<BYTE> job_info_buffer(new BYTE[bytes_needed]);
       if (GetJob(printer_handle, job_id, 1, job_info_buffer.get(), bytes_needed,
                 &bytes_needed)) {
         JOB_INFO_1 *job_info =
             reinterpret_cast<JOB_INFO_1 *>(job_info_buffer.get());
         if (job_info->pStatus) {
           WideToUTF8(job_info->pStatus, wcslen(job_info->pStatus),
                      &job_details->status_message);
         }
         job_details->platform_status_flags = job_info->Status;
         if ((job_info->Status & JOB_STATUS_COMPLETE) ||
             (job_info->Status & JOB_STATUS_PRINTED)) {
           job_details->status = PRINT_JOB_STATUS_COMPLETED;
         } else if (job_info->Status & JOB_STATUS_ERROR) {
           job_details->status = PRINT_JOB_STATUS_ERROR;
         } else {
           job_details->status = PRINT_JOB_STATUS_IN_PROGRESS;
         }
         job_details->total_pages = job_info->TotalPages;
         job_details->pages_printed = job_info->PagesPrinted;
         ret = true;
       }
     }
-    ClosePrinter(printer_handle);
   }
   return ret;
 }
 
 PrintSystem::PrintServerWatcher*
 PrintSystemWin::CreatePrintServerWatcher() {
   return new PrintServerWatcherWin();
 }
 
 PrintSystem::PrinterWatcher* PrintSystemWin::CreatePrinterWatcher(
@@ skipping 26 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