Remove implicit HANDLE conversions from components.

components/storage_monitor/volume_mount_watcher_win.cc

 // Copyright 2014 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 "components/storage_monitor/volume_mount_watcher_win.h"
 
 #include <windows.h>
 
 #include <dbt.h>
 #include <fileapi.h>
@@ skipping 235 matching lines @@
         base::Bind(callback, StorageMonitor::EJECT_FAILURE));
     return;
   }
 
   DWORD bytes_returned = 0;  // Unused, but necessary for ioctl's.
 
   // Lock the drive to be ejected (so that other processes can't open
   // files on it). If this fails, it means some other process has files
   // open on the device. Note that the lock is released when the volume
   // handle is closed, and this is done by the ScopedHandle above.
-  BOOL locked = DeviceIoControl(volume_handle, FSCTL_LOCK_VOLUME,
+  BOOL locked = DeviceIoControl(volume_handle.Get(), FSCTL_LOCK_VOLUME,
                                 NULL, 0, NULL, 0, &bytes_returned, NULL);
   UMA_HISTOGRAM_ENUMERATION("StorageMonitor.EjectWinLock",
                             LOCK_ATTEMPT, NUM_LOCK_OUTCOMES);
   if (!locked) {
     UMA_HISTOGRAM_ENUMERATION("StorageMonitor.EjectWinLock",
                               iteration == 0 ? LOCK_TIMEOUT : LOCK_TIMEOUT2,
                               NUM_LOCK_OUTCOMES);
     const int kNumLockRetries = 1;
     const base::TimeDelta kLockRetryInterval =
         base::TimeDelta::FromMilliseconds(500);
     if (iteration < kNumLockRetries) {
       // Try again -- the lock may have been a transient one. This happens on
       // things like AV disk lock for some reason, or another process
       // transient disk lock.
       task_runner->PostDelayedTask(
           FROM_HERE,
           base::Bind(&EjectDeviceInThreadPool,
                      device, callback, task_runner, iteration + 1),
           kLockRetryInterval);
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback, StorageMonitor::EJECT_IN_USE));
     return;
   }
 
   // Unmount the device from the filesystem -- this will remove it from
   // the file picker, drive enumerations, etc.
-  BOOL dismounted = DeviceIoControl(volume_handle, FSCTL_DISMOUNT_VOLUME,
+  BOOL dismounted = DeviceIoControl(volume_handle.Get(), FSCTL_DISMOUNT_VOLUME,
                                     NULL, 0, NULL, 0, &bytes_returned, NULL);
 
   // Reached if we acquired a lock, but could not dismount. This might
   // occur if another process unmounted without locking. Call this OK,
   // since the volume is now unreachable.
   if (!dismounted) {
-    DeviceIoControl(volume_handle, FSCTL_UNLOCK_VOLUME,
+    DeviceIoControl(volume_handle.Get(), FSCTL_UNLOCK_VOLUME,
                     NULL, 0, NULL, 0, &bytes_returned, NULL);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback, StorageMonitor::EJECT_OK));
     return;
   }
 
   PREVENT_MEDIA_REMOVAL pmr_buffer;
   pmr_buffer.PreventMediaRemoval = FALSE;
   // Mark the device as safe to remove.
-  if (!DeviceIoControl(volume_handle, IOCTL_STORAGE_MEDIA_REMOVAL,
+  if (!DeviceIoControl(volume_handle.Get(), IOCTL_STORAGE_MEDIA_REMOVAL,
                        &pmr_buffer, sizeof(PREVENT_MEDIA_REMOVAL),
                        NULL, 0, &bytes_returned, NULL)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(callback, StorageMonitor::EJECT_FAILURE));
     return;
   }
 
   // Physically eject or soft-eject the device.
-  if (!DeviceIoControl(volume_handle, IOCTL_STORAGE_EJECT_MEDIA,
+  if (!DeviceIoControl(volume_handle.Get(), IOCTL_STORAGE_EJECT_MEDIA,
                        NULL, 0, NULL, 0, &bytes_returned, NULL)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(callback, StorageMonitor::EJECT_FAILURE));
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, StorageMonitor::EJECT_OK));
 }
@@ skipping 223 matching lines @@
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&EjectDeviceInThreadPool, device, callback, task_runner_, 0));
 }
 
 }  // namespace storage_monitor