Implement BluetoothRemoteGattServiceWin and related unit tests

device/bluetooth/bluetooth_task_manager_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 "device/bluetooth/bluetooth_task_manager_win.h"
 
 #include <stddef.h>
 #include <winsock2.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "device/bluetooth/bluetooth_classic_win.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_init_win.h"
-#include "device/bluetooth/bluetooth_low_energy_win.h"
 #include "device/bluetooth/bluetooth_service_record_win.h"
 #include "net/base/winsock_init.h"
 
 namespace {
 
 const int kNumThreadsInWorkerPool = 3;
 const char kBluetoothThreadName[] = "BluetoothPollingThreadWin";
 const int kMaxNumDeviceAddressChar = 127;
 const int kServiceDiscoveryResultBufferSize = 5000;
 
@@ skipping 13 matching lines @@
                                           btha.rgBytes[5],
                                           btha.rgBytes[4],
                                           btha.rgBytes[3],
                                           btha.rgBytes[2],
                                           btha.rgBytes[1],
                                           btha.rgBytes[0]);
   DCHECK_EQ(result, device::BluetoothDevice::CanonicalizeAddress(result));
   return result;
 }
 
-device::BluetoothUUID BluetoothLowEnergyUuidToBluetoothUuid(
-    const BTH_LE_UUID& bth_le_uuid) {
-  if (bth_le_uuid.IsShortUuid) {
-    std::string uuid_hex =
-        base::StringPrintf("%04x", bth_le_uuid.Value.ShortUuid);
-    return device::BluetoothUUID(uuid_hex);
+bool BluetoothUUIDToWinBLEUUID(const device::BluetoothUUID& uuid,
+                               BTH_LE_UUID* out_win_uuid) {
+  if (!uuid.IsValid())
+    return false;
+
+  if (uuid.format() == device::BluetoothUUID::kFormat16Bit) {
+    out_win_uuid->IsShortUuid = true;
+    unsigned int data = 0;
+    int result = sscanf_s(uuid.value().c_str(), "%04x", &data);
+    if (result != 1)
+      return false;
+    out_win_uuid->Value.ShortUuid = data;
   } else {
-    return device::BluetoothUUID(
-        base::StringPrintf("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-                           bth_le_uuid.Value.LongUuid.Data1,
-                           bth_le_uuid.Value.LongUuid.Data2,
-                           bth_le_uuid.Value.LongUuid.Data3,
-                           bth_le_uuid.Value.LongUuid.Data4[0],
-                           bth_le_uuid.Value.LongUuid.Data4[1],
-                           bth_le_uuid.Value.LongUuid.Data4[2],
-                           bth_le_uuid.Value.LongUuid.Data4[3],
-                           bth_le_uuid.Value.LongUuid.Data4[4],
-                           bth_le_uuid.Value.LongUuid.Data4[5],
-                           bth_le_uuid.Value.LongUuid.Data4[6],
-                           bth_le_uuid.Value.LongUuid.Data4[7]));
+    out_win_uuid->IsShortUuid = false;
+    unsigned int data[11];
+    int result =
+        sscanf_s(uuid.value().c_str(),
+                 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", &data[0],
+                 &data[1], &data[2], &data[3], &data[4], &data[5], &data[6],
+                 &data[7], &data[8], &data[9], &data[10]);
+    if (result != 11)
+      return false;
+    out_win_uuid->Value.LongUuid.Data1 = data[0];
+    out_win_uuid->Value.LongUuid.Data2 = data[1];
+    out_win_uuid->Value.LongUuid.Data3 = data[2];
+    out_win_uuid->Value.LongUuid.Data4[0] = data[3];
+    out_win_uuid->Value.LongUuid.Data4[1] = data[4];
+    out_win_uuid->Value.LongUuid.Data4[2] = data[5];
+    out_win_uuid->Value.LongUuid.Data4[3] = data[6];
+    out_win_uuid->Value.LongUuid.Data4[4] = data[7];
+    out_win_uuid->Value.LongUuid.Data4[5] = data[8];
+    out_win_uuid->Value.LongUuid.Data4[6] = data[9];
+    out_win_uuid->Value.LongUuid.Data4[7] = data[10];
   }
+
+  return true;
 }
 
 // Populates bluetooth adapter state using adapter_handle.
 void GetAdapterState(HANDLE adapter_handle,
                      device::BluetoothTaskManagerWin::AdapterState* state) {
   std::string name;
   std::string address;
   bool powered = false;
   BLUETOOTH_RADIO_INFO adapter_info = {sizeof(BLUETOOTH_RADIO_INFO)};
   if (adapter_handle &&
@@ skipping 55 matching lines @@
     : ui_task_runner_(ui_task_runner),
       adapter_handle_(NULL),
       discovering_(false),
       current_logging_batch_count_(0) {}
 
 BluetoothTaskManagerWin::~BluetoothTaskManagerWin() {
   win::BluetoothLowEnergyWrapper::DeleteInstance();
   win::BluetoothClassicWrapper::DeleteInstance();
 }
 
+BluetoothUUID BluetoothTaskManagerWin::BluetoothLowEnergyUuidToBluetoothUuid(
+    const BTH_LE_UUID& bth_le_uuid) {
+  if (bth_le_uuid.IsShortUuid) {
+    std::string uuid_hex =
+        base::StringPrintf("%04x", bth_le_uuid.Value.ShortUuid);
+    return BluetoothUUID(uuid_hex);
+  } else {
+    return BluetoothUUID(base::StringPrintf(
+        "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+        bth_le_uuid.Value.LongUuid.Data1, bth_le_uuid.Value.LongUuid.Data2,
+        bth_le_uuid.Value.LongUuid.Data3, bth_le_uuid.Value.LongUuid.Data4[0],
+        bth_le_uuid.Value.LongUuid.Data4[1],
+        bth_le_uuid.Value.LongUuid.Data4[2],
+        bth_le_uuid.Value.LongUuid.Data4[3],
+        bth_le_uuid.Value.LongUuid.Data4[4],
+        bth_le_uuid.Value.LongUuid.Data4[5],
+        bth_le_uuid.Value.LongUuid.Data4[6],
+        bth_le_uuid.Value.LongUuid.Data4[7]));
+  }
+}
+
 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
   DCHECK(observer);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   observers_.AddObserver(observer);
 }
 
 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
   DCHECK(observer);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   observers_.RemoveObserver(observer);
@@ skipping 312 matching lines @@
   if (!win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle)) {
     LogPollingError("Error calling BluetoothFindDeviceClose",
                     win::BluetoothClassicWrapper::GetInstance()->LastError());
     return false;
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
     ScopedVector<DeviceState>* device_list) {
-  if (!win::IsBluetoothLowEnergySupported())
+  if (!win::BluetoothLowEnergyWrapper::GetInstance()
+           ->IsBluetoothLowEnergySupported()) {
     return true;  // Bluetooth LE not supported is not an error.
+  }
 
   ScopedVector<win::BluetoothLowEnergyDeviceInfo> btle_devices;
   std::string error;
   bool success =
       win::BluetoothLowEnergyWrapper::GetInstance()
           ->EnumerateKnownBluetoothLowEnergyDevices(&btle_devices, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
@@ skipping 140 matching lines @@
     LogPollingError("Error calling WSALookupServiceEnd", last_error);
     return last_error;
   }
 
   return ERROR_SUCCESS;
 }
 
 bool BluetoothTaskManagerWin::DiscoverLowEnergyDeviceServices(
     const base::FilePath& device_path,
     ScopedVector<ServiceRecordState>* service_record_states) {
-  if (!win::IsBluetoothLowEnergySupported())
+  if (!win::BluetoothLowEnergyWrapper::GetInstance()
+           ->IsBluetoothLowEnergySupported()) {
     return true;  // Bluetooth LE not supported is not an error.
+  }
 
   std::string error;
   ScopedVector<win::BluetoothLowEnergyServiceInfo> services;
   bool success = win::BluetoothLowEnergyWrapper::GetInstance()
                      ->EnumerateKnownBluetoothLowEnergyServices(
                          device_path, &services, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
@@ skipping 62 matching lines @@
           service_record_state->path = gatt_service_device->path;
           break;
         }
       }
     }
   }
 
   return true;
 }
 
+void BluetoothTaskManagerWin::GetGattIncludedCharacteristics(
+    base::FilePath service_path,
+    BluetoothUUID uuid,
+    uint16_t attribute_handle,
+    const GetGattIncludedCharacteristicsCallback& callback) {
+  HRESULT hr = S_OK;
+  scoped_ptr<BTH_LE_GATT_CHARACTERISTIC> win_characteristics_info;
+  uint16_t number_of_charateristics = 0;
+
+  BTH_LE_GATT_SERVICE win_service;
+  if (BluetoothUUIDToWinBLEUUID(uuid, &(win_service.ServiceUuid))) {
+    win_service.AttributeHandle = attribute_handle;
+    hr = win::BluetoothLowEnergyWrapper::GetInstance()
+             ->ReadCharacteristicsOfAService(service_path, &win_service,
+                                             &win_characteristics_info,
+                                             &number_of_charateristics);
+  } else {
+    hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
+  }
+
+  ui_task_runner_->PostTask(
+      FROM_HERE, base::Bind(callback, base::Passed(&win_characteristics_info),
+                            number_of_charateristics, hr));
+}
+
+void BluetoothTaskManagerWin::PostGetGattIncludedCharacteristics(
+    const base::FilePath& service_path,
+    const BluetoothUUID& uuid,
+    uint16_t attribute_handle,
+    const GetGattIncludedCharacteristicsCallback& callback) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  bluetooth_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BluetoothTaskManagerWin::GetGattIncludedCharacteristics, this,
+                 service_path, uuid, attribute_handle, callback));
+}
+
 }  // namespace device