Remove implicit HANDLE conversions from device.

device/bluetooth/bluetooth_low_energy_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 "device/bluetooth/bluetooth_low_energy_win.h"
 
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_handle.h"
@@ skipping 153 matching lines @@
 }
 
 bool CollectBluetoothLowEnergyDeviceProperty(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     const DEVPROPKEY& key,
     scoped_ptr<DevicePropertyValue>* value,
     std::string* error) {
   DWORD required_length;
   DEVPROPTYPE prop_type;
-  BOOL success = SetupDiGetDeviceProperty(device_info_handle,
+  BOOL success = SetupDiGetDeviceProperty(device_info_handle.Get(),
                                           device_info_data,
                                           &key,
                                           &prop_type,
                                           NULL,
                                           0,
                                           &required_length,
                                           0);
   if (!CheckInsufficientBuffer(!!success, kDeviceInfoError, error))
     return false;
 
   scoped_ptr<uint8_t[]> prop_value(new uint8_t[required_length]);
   DWORD actual_length = required_length;
-  success = SetupDiGetDeviceProperty(device_info_handle,
+  success = SetupDiGetDeviceProperty(device_info_handle.Get(),
                                      device_info_data,
                                      &key,
                                      &prop_type,
                                      prop_value.get(),
                                      actual_length,
                                      &required_length,
                                      0);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
 
   (*value) = scoped_ptr<DevicePropertyValue>(
       new DevicePropertyValue(prop_type, prop_value.Pass(), actual_length));
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceRegistryProperty(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     DWORD property_id,
     scoped_ptr<DeviceRegistryPropertyValue>* value,
     std::string* error) {
   ULONG required_length = 0;
-  BOOL success = SetupDiGetDeviceRegistryProperty(device_info_handle,
+  BOOL success = SetupDiGetDeviceRegistryProperty(device_info_handle.Get(),
                                                   device_info_data,
                                                   property_id,
                                                   NULL,
                                                   NULL,
                                                   0,
                                                   &required_length);
   if (!CheckInsufficientBuffer(!!success, kDeviceInfoError, error))
     return false;
 
   scoped_ptr<uint8_t[]> property_value(new uint8_t[required_length]);
   ULONG actual_length = required_length;
   DWORD property_type;
-  success = SetupDiGetDeviceRegistryProperty(device_info_handle,
+  success = SetupDiGetDeviceRegistryProperty(device_info_handle.Get(),
                                              device_info_data,
                                              property_id,
                                              &property_type,
                                              property_value.get(),
                                              actual_length,
                                              &required_length);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
 
   (*value) = DeviceRegistryPropertyValue::Create(
                  property_type, property_value.Pass(), actual_length).Pass();
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceInstanceId(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>& device_info,
     std::string* error) {
   ULONG required_length = 0;
   BOOL success = SetupDiGetDeviceInstanceId(
-      device_info_handle, device_info_data, NULL, 0, &required_length);
+      device_info_handle.Get(), device_info_data, NULL, 0, &required_length);
   if (!CheckInsufficientBuffer(!!success, kDeviceInfoError, error))
     return false;
 
   scoped_ptr<WCHAR[]> instance_id(new WCHAR[required_length]);
   ULONG actual_length = required_length;
-  success = SetupDiGetDeviceInstanceId(device_info_handle,
+  success = SetupDiGetDeviceInstanceId(device_info_handle.Get(),
                                        device_info_data,
                                        instance_id.get(),
                                        actual_length,
                                        &required_length);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
@@ skipping 140 matching lines @@
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceInfo(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVICE_INTERFACE_DATA device_interface_data,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>* device_info,
     std::string* error) {
   // Retrieve required # of bytes for interface details
   ULONG required_length = 0;
-  BOOL success = SetupDiGetDeviceInterfaceDetail(device_info_handle,
+  BOOL success = SetupDiGetDeviceInterfaceDetail(device_info_handle.Get(),
                                                  device_interface_data,
                                                  NULL,
                                                  0,
                                                  &required_length,
                                                  NULL);
   if (!CheckInsufficientBuffer(!!success, kDeviceInfoError, error))
     return false;
 
   scoped_ptr<uint8_t[]> interface_data(new uint8_t[required_length]);
   ZeroMemory(interface_data.get(), required_length);
 
   PSP_DEVICE_INTERFACE_DETAIL_DATA device_interface_detail_data =
       reinterpret_cast<PSP_DEVICE_INTERFACE_DETAIL_DATA>(interface_data.get());
   device_interface_detail_data->cbSize =
       sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
 
   SP_DEVINFO_DATA device_info_data = {0};
   device_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
 
   ULONG actual_length = required_length;
-  success = SetupDiGetDeviceInterfaceDetail(device_info_handle,
+  success = SetupDiGetDeviceInterfaceDetail(device_info_handle.Get(),
                                             device_interface_data,
                                             device_interface_detail_data,
                                             actual_length,
                                             &required_length,
                                             &device_info_data);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
@@ skipping 27 matching lines @@
 
 DeviceInfoResult EnumerateSingleBluetoothLowEnergyDevice(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     DWORD device_index,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>* device_info,
     std::string* error) {
   // Enumerate device of BLUETOOTHLE_DEVICE interface class
   GUID BluetoothInterfaceGUID = GUID_BLUETOOTHLE_DEVICE_INTERFACE;
   SP_DEVICE_INTERFACE_DATA device_interface_data = {0};
   device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
-  BOOL success = ::SetupDiEnumDeviceInterfaces(device_info_handle,
+  BOOL success = ::SetupDiEnumDeviceInterfaces(device_info_handle.Get(),
                                                NULL,
                                                &BluetoothInterfaceGUID,
                                                device_index,
                                                &device_interface_data);
   if (!success) {
     HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
     if (hr == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS)) {
       return kNoMoreDevices;
     }
     *error = FormatBluetoothError(kDeviceInfoError, hr);
@@ skipping 165 matching lines @@
 
 bool ExtractBluetoothAddressFromDeviceInstanceIdForTesting(
     const std::string& instance_id,
     BLUETOOTH_ADDRESS* btha,
     std::string* error) {
   return ExtractBluetoothAddressFromDeviceInstanceId(instance_id, btha, error);
 }
 
 }  // namespace win
 }  // namespace device