Remove implicit HANDLE conversions from chrome.

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 "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 50 matching lines @@
     // NULL to OpenPrinter.
     LPTSTR printer_name_to_use = NULL;
     std::wstring printer_name_wide;
     if (!printer_name.empty()) {
       printer_name_wide = base::UTF8ToWide(printer_name);
       printer_name_to_use = const_cast<LPTSTR>(printer_name_wide.c_str());
     }
     bool ret = false;
     if (printer_.OpenPrinter(printer_name_to_use)) {
       printer_change_.Set(FindFirstPrinterChangeNotification(
-          printer_, PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB, 0, NULL));
+          printer_.Get(), PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB, 0, NULL));
       if (printer_change_.IsValid()) {
-        ret = watcher_.StartWatching(printer_change_, this);
+        ret = watcher_.StartWatching(printer_change_.Get(), this);
       }
     }
     if (!ret) {
       Stop();
     }
     return ret;
   }
 
   bool Stop() {
     watcher_.StopWatching();
@@ skipping 17 matching lines @@
         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);
+    watcher_.StartWatching(printer_change_.Get(), this);
   }
 
   bool GetCurrentPrinterInfo(printing::PrinterBasicInfo* printer_info) {
     DCHECK(printer_info);
-    return InitBasicPrinterInfo(printer_, printer_info);
+    return InitBasicPrinterInfo(printer_.Get(), printer_info);
   }
 
  private:
   base::win::ObjectWatcher watcher_;
   printing::ScopedPrinterHandle printer_;  // The printer being watched
   // Returned by FindFirstPrinterChangeNotifier.
   printing::ScopedPrinterChangeHandle printer_change_;
   Delegate* delegate_;           // Delegate to notify
   bool did_signal_;              // DoneWaiting was called
   std::string printer_info_;     // For crash reporting.
@@ skipping 19 matching lines @@
   }
 
   // PrintSystemWatcherWin::Delegate implementation.
   virtual void OnPrinterAdded() OVERRIDE {
     delegate_->OnPrinterAdded();
   }
   virtual void OnPrinterDeleted() OVERRIDE {}
   virtual void OnPrinterChanged() OVERRIDE {}
   virtual void OnJobChanged() OVERRIDE {}
 
-  protected:
+ protected:
   virtual ~PrintServerWatcherWin() {}
 
  private:
   PrintSystem::PrintServerWatcher::Delegate* delegate_;
   PrintSystemWatcherWin watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherWin);
 };
 
 class PrinterWatcherWin
@@ skipping 30 matching lines @@
   virtual void OnPrinterDeleted() OVERRIDE {
     delegate_->OnPrinterDeleted();
   }
   virtual void OnPrinterChanged() OVERRIDE {
     delegate_->OnPrinterChanged();
   }
   virtual void OnJobChanged() OVERRIDE {
     delegate_->OnJobChanged();
   }
 
-  protected:
+ protected:
   virtual ~PrinterWatcherWin() {}
 
  private:
   std::string printer_name_;
   PrintSystem::PrinterWatcher::Delegate* delegate_;
   PrintSystemWatcherWin watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterWatcherWin);
 };
 
@@ skipping 527 matching lines @@
   crash_keys::ScopedPrinterInfo crash_key(
       print_backend_->GetPrinterDriverInfo(printer_name));
   DCHECK(job_details);
   printing::ScopedPrinterHandle printer_handle;
   std::wstring printer_name_wide = base::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);
+    GetJob(printer_handle.Get(), 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_ptr<BYTE[]> job_info_buffer(new BYTE[bytes_needed]);
-      if (GetJob(printer_handle, job_id, 1, job_info_buffer.get(), bytes_needed,
-                &bytes_needed)) {
+      if (GetJob(printer_handle.Get(), 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) {
           base::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;
@@ skipping 46 matching lines @@
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print