Enumerate Bluetooth LE services and expose them to chrome.bluetooth API.

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 <winsock2.h>
 
 #include <string>
 
@@ skipping 24 matching lines @@
 std::string BluetoothAddressToString(const BLUETOOTH_ADDRESS& btha) {
   return base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X",
                             btha.rgBytes[5],
                             btha.rgBytes[4],
                             btha.rgBytes[3],
                             btha.rgBytes[2],
                             btha.rgBytes[1],
                             btha.rgBytes[0]);
 }
 
+device::BluetoothUUID BluetoothLowEnergyUuidToUBluetoothUuid(
+    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);
+  } 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]));
+  }
+}
+
 // 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), 0 };
   if (adapter_handle &&
       ERROR_SUCCESS == BluetoothGetRadioInfo(adapter_handle,
                                              &adapter_info)) {
@@ skipping 42 matching lines @@
   while (true) {
     DWORD sdp_buffer_size = sizeof(sdp_buffer);
     if (ERROR_SUCCESS !=
         WSALookupServiceNext(
             sdp_handle, LUP_RETURN_ALL, &sdp_buffer_size, sdp_result_data)) {
       break;
     }
     ServiceRecordState* service_record_state = new ServiceRecordState();
     service_record_state->name =
         base::SysWideToUTF8(sdp_result_data->lpszServiceInstanceName);
-    service_record_state->address = device_address;
     for (uint64 i = 0; i < sdp_result_data->lpBlob->cbSize; i++) {
       service_record_state->sdp_bytes.push_back(
           sdp_result_data->lpBlob->pBlobData[i]);
     }
     service_record_states->push_back(service_record_state);
   }
   WSALookupServiceEnd(sdp_handle);
 }
 
 }  // namespace
@@ skipping 285 matching lines @@
            ++iter) {
         win::BluetoothLowEnergyDeviceInfo* device_info = (*iter);
 
         DeviceState* device_state = new DeviceState();
         device_state->name = device_info->friendly_name;
         device_state->address = BluetoothAddressToString(device_info->address);
         device_state->visible = device_info->visible;
         device_state->authenticated = device_info->authenticated;
         device_state->connected = device_info->connected;
         device_state->path = device_info->path;
+
+        ScopedVector<win::BluetoothLowEnergyServiceInfo> services;
+        success = win::EnumerateKnownBluetoothLowEnergyServices(
+            device_info, &services, &error);
+        if (success) {
+          for (ScopedVector<win::BluetoothLowEnergyServiceInfo>::iterator
+                   iter2 = services.begin();
+               iter2 != services.end();
+               ++iter2) {
+            ServiceRecordState* service_state = new ServiceRecordState();
+            service_state->gatt_uuid =
+                BluetoothLowEnergyUuidToUBluetoothUuid((*iter2)->uuid);
+            device_state->service_record_states.push_back(service_state);
+          }
+        }
         device_list->push_back(device_state);
       }
     }
   }
 
   if (device_list->empty()) {
     delete device_list;
     return;
   }
   DiscoverServices(device_list);
@@ skipping 44 matching lines @@
     const std::string device_address = (*iter)->address;
     ScopedVector<ServiceRecordState>* service_record_states =
         &(*iter)->service_record_states;
 
     DiscoverDeviceServices(
         device_address, L2CAP_PROTOCOL_UUID, service_record_states);
   }
 }
 
 }  // namespace device