Revert 282212 "Retrieve "connected" property from BLE devices."

trunk/src/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 <cfg.h>
-#define INITGUID  // For DEVPKEY_Xxxx guid/pid pairs
-#include <devpkey.h>
-
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/windows_version.h"
 
 namespace {
 
 using device::win::DeviceRegistryPropertyValue;
-using device::win::DevicePropertyValue;
 
 const char kPlatformNotSupported[] =
     "Bluetooth Low energy is only supported on Windows 8 and later.";
 const char kDeviceEnumError[] = "Error enumerating Bluetooth LE devices.";
 const char kDeviceInfoError[] =
     "Error retrieving Bluetooth LE device information.";
 const char kDeviceAddressError[] =
     "Device instance ID value does not seem to contain a Bluetooth Adapter "
     "address.";
 const char kDeviceFriendlyNameError[] = "Device name is not valid.";
@@ skipping 94 matching lines @@
                          const char* message,
                          std::string* error) {
   if (actual_length != expected_length) {
     *error = FormatBluetoothError(message, E_FAIL);
     return false;
   }
 
   return true;
 }
 
-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,
-                                          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,
-                                     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,
                                                   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]);
+  scoped_ptr<UINT8[]> property_value(new UINT8[required_length]);
   ULONG actual_length = required_length;
   DWORD property_type;
   success = SetupDiGetDeviceRegistryProperty(device_info_handle,
                                              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)) {
+          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,
@@ skipping 78 matching lines @@
     std::string* error) {
   // TODO(rpaquay): We exctract the bluetooth device address from the device
   // instance ID string, as we did not find a more formal API for retrieving the
   // bluetooth address of a Bluetooth Low Energy device.
   // An Bluetooth device instance ID has the following format (under Win8+):
   // BTHLE\DEV_BC6A29AB5FB0\8&31038925&0&BC6A29AB5FB0
   return ExtractBluetoothAddressFromDeviceInstanceId(
       device_info->id, &device_info->address, error);
 }
 
-bool CollectBluetoothLowEnergyDeviceStatus(
-    const ScopedDeviceInfoSetHandle& device_info_handle,
-    PSP_DEVINFO_DATA device_info_data,
-    scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>& device_info,
-    std::string* error) {
-  scoped_ptr<DevicePropertyValue> value;
-  if (!CollectBluetoothLowEnergyDeviceProperty(device_info_handle,
-                                               device_info_data,
-                                               DEVPKEY_Device_DevNodeStatus,
-                                               &value,
-                                               error)) {
-    return false;
-  }
-
-  if (value->property_type() != DEVPROP_TYPE_UINT32) {
-    *error = kDeviceInfoError;
-    return false;
-  }
-
-  device_info->connected = !(value->AsUint32() & DN_DEVICE_DISCONNECTED);
-  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,
                                                  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]);
+  scoped_ptr<UINT8[]> interface_data(new UINT8[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,
                                             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)) {
+          actual_length, required_length, kDeviceInfoError, error))
     return false;
-  }
 
   scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo> result(
       new device::win::BluetoothLowEnergyDeviceInfo());
   result->path =
       base::FilePath(std::wstring(device_interface_detail_data->DevicePath));
   if (!CollectBluetoothLowEnergyDeviceInstanceId(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
   if (!CollectDeviceFriendlyName(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
   if (!CollectBluetoothLowEnergyDeviceAddress(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
-  if (!CollectBluetoothLowEnergyDeviceStatus(
-          device_info_handle, &device_info_data, result, error)) {
-    return false;
-  }
   (*device_info) = result.Pass();
   return true;
 }
 
 enum DeviceInfoResult { kOk, kError, kNoMoreDevices };
 
 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
+  // Enumerate device of LE_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,
                                                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);
     return kError;
   }
 
   if (!CollectBluetoothLowEnergyDeviceInfo(
-          device_info_handle, &device_interface_data, device_info, error)) {
+          device_info_handle, &device_interface_data, device_info, error))
     return kError;
-  }
 
   return kOk;
 }
 
 // Opens a Device Info Set that can be used to enumerate Bluetooth LE devices
 // present on the machine.
 HRESULT OpenBluetoothLowEnergyDevices(ScopedDeviceInfoSetHandle* handle) {
   GUID BluetoothClassGUID = GUID_BLUETOOTHLE_DEVICE_INTERFACE;
   ScopedDeviceInfoSetHandle result(SetupDiGetClassDevs(
       &BluetoothClassGUID, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
@@ skipping 65 matching lines @@
   WCHAR* value_string = reinterpret_cast<WCHAR*>(value_.get());
   return base::SysWideToUTF8(value_string);
 }
 
 DWORD DeviceRegistryPropertyValue::AsDWORD() const {
   CHECK_EQ(property_type_, static_cast<DWORD>(REG_DWORD));
   DWORD* value = reinterpret_cast<DWORD*>(value_.get());
   return *value;
 }
 
-DevicePropertyValue::DevicePropertyValue(DEVPROPTYPE property_type,
-                                         scoped_ptr<uint8_t[]> value,
-                                         size_t value_size)
-    : property_type_(property_type),
-      value_(value.Pass()),
-      value_size_(value_size) {
-}
-
-uint32_t DevicePropertyValue::AsUint32() const {
-  CHECK_EQ(property_type_, static_cast<DEVPROPTYPE>(DEVPROP_TYPE_UINT32));
-  CHECK_EQ(value_size_, sizeof(uint32_t));
-  return *reinterpret_cast<uint32_t*>(value_.get());
-}
-
-BluetoothLowEnergyDeviceInfo::BluetoothLowEnergyDeviceInfo()
-    : connected(false) {
-  address.ullLong = BLUETOOTH_NULL_ADDRESS;
-}
-
-BluetoothLowEnergyDeviceInfo::~BluetoothLowEnergyDeviceInfo() {
-}
-
 bool IsBluetoothLowEnergySupported() {
   return base::win::GetVersion() >= base::win::VERSION_WIN8;
 }
 
 bool EnumerateKnownBluetoothLowEnergyDevices(
     ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
@@ skipping 23 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