device/bluetooth/bluetooth_task_manager_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "device/bluetooth/bluetooth_task_manager_win.h"
   6
   7 #include <winsock2.h>
   8
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/sequenced_task_runner.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/strings/sys_string_conversions.h"
  18 #include "base/threading/sequenced_worker_pool.h"
  19 #include "base/win/scoped_handle.h"
  20 #include "device/bluetooth/bluetooth_device.h"
  21 #include "device/bluetooth/bluetooth_init_win.h"
  22 #include "device/bluetooth/bluetooth_low_energy_win.h"
  23 #include "device/bluetooth/bluetooth_service_record_win.h"
  24 #include "net/base/winsock_init.h"
  25
  26 namespace {
  27
  28 const int kNumThreadsInWorkerPool = 3;
  29 const char kBluetoothThreadName[] = "BluetoothPollingThreadWin";
  30 const int kMaxNumDeviceAddressChar = 127;
  31 const int kServiceDiscoveryResultBufferSize = 5000;
  32
  33 // See http://goo.gl/iNTRQe: cTimeoutMultiplier: A value that indicates the time
  34 // out for the inquiry, expressed in increments of 1.28 seconds. For example, an
  35 // inquiry of 12.8 seconds has a cTimeoutMultiplier value of 10. The maximum
  36 // value for this member is 48. When a value greater than 48 is used, the
  37 // calling function immediately fails and returns
  38 const int kMaxDeviceDiscoveryTimeoutMultiplier = 48;
  39
  40 typedef device::BluetoothTaskManagerWin::ServiceRecordState ServiceRecordState;
  41
  42 // Note: The string returned here must have the same format as
  43 // BluetoothDevice::CanonicalizeAddress.
  44 std::string BluetoothAddressToCanonicalString(const BLUETOOTH_ADDRESS& btha) {
  45   std::string result = base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X",
  46                                           btha.rgBytes[5],
  47                                           btha.rgBytes[4],
  48                                           btha.rgBytes[3],
  49                                           btha.rgBytes[2],
  50                                           btha.rgBytes[1],
  51                                           btha.rgBytes[0]);
  52   DCHECK_EQ(result, device::BluetoothDevice::CanonicalizeAddress(result));
  53   return result;
  54 }
  55
  56 device::BluetoothUUID BluetoothLowEnergyUuidToBluetoothUuid(
  57     const BTH_LE_UUID& bth_le_uuid) {
  58   if (bth_le_uuid.IsShortUuid) {
  59     std::string uuid_hex =
  60         base::StringPrintf("%04x", bth_le_uuid.Value.ShortUuid);
  61     return device::BluetoothUUID(uuid_hex);
  62   } else {
  63     return device::BluetoothUUID(
  64         base::StringPrintf("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
  65                            bth_le_uuid.Value.LongUuid.Data1,
  66                            bth_le_uuid.Value.LongUuid.Data2,
  67                            bth_le_uuid.Value.LongUuid.Data3,
  68                            bth_le_uuid.Value.LongUuid.Data4[0],
  69                            bth_le_uuid.Value.LongUuid.Data4[1],
  70                            bth_le_uuid.Value.LongUuid.Data4[2],
  71                            bth_le_uuid.Value.LongUuid.Data4[3],
  72                            bth_le_uuid.Value.LongUuid.Data4[4],
  73                            bth_le_uuid.Value.LongUuid.Data4[5],
  74                            bth_le_uuid.Value.LongUuid.Data4[6],
  75                            bth_le_uuid.Value.LongUuid.Data4[7]));
  76   }
  77 }
  78
  79 // Populates bluetooth adapter state using adapter_handle.
  80 void GetAdapterState(HANDLE adapter_handle,
  81                      device::BluetoothTaskManagerWin::AdapterState* state) {
  82   std::string name;
  83   std::string address;
  84   bool powered = false;
  85   BLUETOOTH_RADIO_INFO adapter_info = { sizeof(BLUETOOTH_RADIO_INFO), 0 };
  86   if (adapter_handle &&
  87       ERROR_SUCCESS == BluetoothGetRadioInfo(adapter_handle,
  88                                              &adapter_info)) {
  89     name = base::SysWideToUTF8(adapter_info.szName);
  90     address = BluetoothAddressToCanonicalString(adapter_info.address);
  91     powered = !!BluetoothIsConnectable(adapter_handle);
  92   }
  93   state->name = name;
  94   state->address = address;
  95   state->powered = powered;
  96 }
  97
  98 void GetDeviceState(const BLUETOOTH_DEVICE_INFO& device_info,
  99                     device::BluetoothTaskManagerWin::DeviceState* state) {
 100   state->name = base::SysWideToUTF8(device_info.szName);
 101   state->address = BluetoothAddressToCanonicalString(device_info.Address);
 102   state->bluetooth_class = device_info.ulClassofDevice;
 103   state->visible = true;
 104   state->connected = !!device_info.fConnected;
 105   state->authenticated = !!device_info.fAuthenticated;
 106 }
 107
 108 }  // namespace
 109
 110 namespace device {
 111
 112 // static
 113 const int BluetoothTaskManagerWin::kPollIntervalMs = 500;
 114
 115 BluetoothTaskManagerWin::AdapterState::AdapterState() : powered(false) {
 116 }
 117
 118 BluetoothTaskManagerWin::AdapterState::~AdapterState() {
 119 }
 120
 121 BluetoothTaskManagerWin::ServiceRecordState::ServiceRecordState() {
 122 }
 123
 124 BluetoothTaskManagerWin::ServiceRecordState::~ServiceRecordState() {
 125 }
 126
 127 BluetoothTaskManagerWin::DeviceState::DeviceState()
 128     : bluetooth_class(0),
 129       visible(false),
 130       connected(false),
 131       authenticated(false) {
 132 }
 133
 134 BluetoothTaskManagerWin::DeviceState::~DeviceState() {
 135 }
 136
 137 BluetoothTaskManagerWin::BluetoothTaskManagerWin(
 138     scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
 139     : ui_task_runner_(ui_task_runner),
 140       discovering_(false),
 141       current_logging_batch_count_(0) {
 142 }
 143
 144 BluetoothTaskManagerWin::~BluetoothTaskManagerWin() {
 145 }
 146
 147 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
 148   DCHECK(observer);
 149   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 150   observers_.AddObserver(observer);
 151 }
 152
 153 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
 154   DCHECK(observer);
 155   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 156   observers_.RemoveObserver(observer);
 157 }
 158
 159 void BluetoothTaskManagerWin::Initialize() {
 160   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 161   worker_pool_ = new base::SequencedWorkerPool(kNumThreadsInWorkerPool,
 162                                                kBluetoothThreadName);
 163   InitializeWithBluetoothTaskRunner(
 164       worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
 165           worker_pool_->GetSequenceToken(),
 166           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
 167 }
 168
 169 void BluetoothTaskManagerWin::InitializeWithBluetoothTaskRunner(
 170     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
 171   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 172   bluetooth_task_runner_ = bluetooth_task_runner;
 173   bluetooth_task_runner_->PostTask(
 174       FROM_HERE,
 175       base::Bind(&BluetoothTaskManagerWin::StartPolling, this));
 176 }
 177
 178 void BluetoothTaskManagerWin::StartPolling() {
 179   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 180
 181   if (device::bluetooth_init_win::HasBluetoothStack()) {
 182     PollAdapter();
 183   } else {
 184     // IF the bluetooth stack is not available, we still send an empty state
 185     // to BluetoothAdapter so that it is marked initialized, but the adapter
 186     // will not be present.
 187     AdapterState* state = new AdapterState();
 188     ui_task_runner_->PostTask(
 189       FROM_HERE,
 190       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
 191                  this,
 192                  base::Owned(state)));
 193   }
 194 }
 195
 196 void BluetoothTaskManagerWin::Shutdown() {
 197   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 198   if (worker_pool_)
 199     worker_pool_->Shutdown();
 200 }
 201
 202 void BluetoothTaskManagerWin::PostSetPoweredBluetoothTask(
 203     bool powered,
 204     const base::Closure& callback,
 205     const BluetoothAdapter::ErrorCallback& error_callback) {
 206   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 207   bluetooth_task_runner_->PostTask(
 208       FROM_HERE,
 209       base::Bind(&BluetoothTaskManagerWin::SetPowered,
 210                  this,
 211                  powered,
 212                  callback,
 213                  error_callback));
 214 }
 215
 216 void BluetoothTaskManagerWin::PostStartDiscoveryTask() {
 217   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 218   bluetooth_task_runner_->PostTask(
 219       FROM_HERE,
 220       base::Bind(&BluetoothTaskManagerWin::StartDiscovery, this));
 221 }
 222
 223 void BluetoothTaskManagerWin::PostStopDiscoveryTask() {
 224   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 225   bluetooth_task_runner_->PostTask(
 226       FROM_HERE,
 227       base::Bind(&BluetoothTaskManagerWin::StopDiscovery, this));
 228 }
 229
 230 void BluetoothTaskManagerWin::LogPollingError(const char* message,
 231                                               int win32_error) {
 232   const int kLogPeriodInMilliseconds = 60 * 1000;
 233   const int kMaxMessagesPerLogPeriod = 10;
 234
 235   // Check if we need to discard this message
 236   if (!current_logging_batch_ticks_.is_null()) {
 237     if (base::TimeTicks::Now() - current_logging_batch_ticks_ <=
 238         base::TimeDelta::FromMilliseconds(kLogPeriodInMilliseconds)) {
 239       if (current_logging_batch_count_ >= kMaxMessagesPerLogPeriod)
 240         return;
 241     } else {
 242       // The batch expired, reset it to "null".
 243       current_logging_batch_ticks_ = base::TimeTicks();
 244     }
 245   }
 246
 247   // Keep track of this batch of messages
 248   if (current_logging_batch_ticks_.is_null()) {
 249     current_logging_batch_ticks_ = base::TimeTicks::Now();
 250     current_logging_batch_count_ = 0;
 251   }
 252   ++current_logging_batch_count_;
 253
 254   // Log the message
 255   if (win32_error == 0)
 256     LOG(WARNING) << message;
 257   else
 258     LOG(WARNING) << message << ": "
 259                  << logging::SystemErrorCodeToString(win32_error);
 260 }
 261
 262 void BluetoothTaskManagerWin::OnAdapterStateChanged(const AdapterState* state) {
 263   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 264   FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_,
 265                     AdapterStateChanged(*state));
 266 }
 267
 268 void BluetoothTaskManagerWin::OnDiscoveryStarted(bool success) {
 269   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 270   FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_,
 271                     DiscoveryStarted(success));
 272 }
 273
 274 void BluetoothTaskManagerWin::OnDiscoveryStopped() {
 275   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 276   FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_,
 277                     DiscoveryStopped());
 278 }
 279
 280 void BluetoothTaskManagerWin::OnDevicesPolled(
 281     const ScopedVector<DeviceState>* devices) {
 282   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 283   FOR_EACH_OBSERVER(
 284       BluetoothTaskManagerWin::Observer, observers_, DevicesPolled(*devices));
 285 }
 286
 287 void BluetoothTaskManagerWin::PollAdapter() {
 288   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 289
 290   // Skips updating the adapter info if the adapter is in discovery mode.
 291   if (!discovering_) {
 292     const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
 293         { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
 294     if (adapter_handle_)
 295       adapter_handle_.Close();
 296     HANDLE temp_adapter_handle;
 297     HBLUETOOTH_RADIO_FIND handle = BluetoothFindFirstRadio(
 298         &adapter_param, &temp_adapter_handle);
 299
 300     if (handle) {
 301       adapter_handle_.Set(temp_adapter_handle);
 302       GetKnownDevices();
 303       BluetoothFindRadioClose(handle);
 304     }
 305
 306     PostAdapterStateToUi();
 307   }
 308
 309   // Re-poll.
 310   bluetooth_task_runner_->PostDelayedTask(
 311       FROM_HERE,
 312       base::Bind(&BluetoothTaskManagerWin::PollAdapter,
 313                  this),
 314       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 315 }
 316
 317 void BluetoothTaskManagerWin::PostAdapterStateToUi() {
 318   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 319   AdapterState* state = new AdapterState();
 320   GetAdapterState(adapter_handle_, state);
 321   ui_task_runner_->PostTask(
 322       FROM_HERE,
 323       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
 324                  this,
 325                  base::Owned(state)));
 326 }
 327
 328 void BluetoothTaskManagerWin::SetPowered(
 329     bool powered,
 330     const base::Closure& callback,
 331     const BluetoothAdapter::ErrorCallback& error_callback) {
 332   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 333   bool success = false;
 334   if (adapter_handle_) {
 335     if (!powered)
 336       BluetoothEnableDiscovery(adapter_handle_, false);
 337     success = !!BluetoothEnableIncomingConnections(adapter_handle_, powered);
 338   }
 339
 340   if (success) {
 341     PostAdapterStateToUi();
 342     ui_task_runner_->PostTask(FROM_HERE, callback);
 343   } else {
 344     ui_task_runner_->PostTask(FROM_HERE, error_callback);
 345   }
 346 }
 347
 348 void BluetoothTaskManagerWin::StartDiscovery() {
 349   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 350   ui_task_runner_->PostTask(
 351       FROM_HERE,
 352       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted,
 353                  this,
 354                  !!adapter_handle_));
 355   if (!adapter_handle_)
 356     return;
 357   discovering_ = true;
 358
 359   DiscoverDevices(1);
 360 }
 361
 362 void BluetoothTaskManagerWin::StopDiscovery() {
 363   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 364   discovering_ = false;
 365   ui_task_runner_->PostTask(
 366       FROM_HERE,
 367       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
 368 }
 369
 370 void BluetoothTaskManagerWin::DiscoverDevices(int timeout_multiplier) {
 371   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 372   if (!discovering_ || !adapter_handle_) {
 373     ui_task_runner_->PostTask(
 374         FROM_HERE,
 375         base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
 376     return;
 377   }
 378
 379   scoped_ptr<ScopedVector<DeviceState> > device_list(
 380       new ScopedVector<DeviceState>());
 381   if (SearchDevices(timeout_multiplier, false, device_list.get())) {
 382     ui_task_runner_->PostTask(
 383         FROM_HERE,
 384         base::Bind(&BluetoothTaskManagerWin::OnDevicesPolled,
 385                    this,
 386                    base::Owned(device_list.release())));
 387   }
 388
 389   if (timeout_multiplier < kMaxDeviceDiscoveryTimeoutMultiplier)
 390     ++timeout_multiplier;
 391   bluetooth_task_runner_->PostTask(
 392       FROM_HERE,
 393       base::Bind(
 394           &BluetoothTaskManagerWin::DiscoverDevices, this, timeout_multiplier));
 395 }
 396
 397 void BluetoothTaskManagerWin::GetKnownDevices() {
 398   scoped_ptr<ScopedVector<DeviceState> > device_list(
 399       new ScopedVector<DeviceState>());
 400   if (SearchDevices(1, true, device_list.get())) {
 401     ui_task_runner_->PostTask(
 402         FROM_HERE,
 403         base::Bind(&BluetoothTaskManagerWin::OnDevicesPolled,
 404                    this,
 405                    base::Owned(device_list.release())));
 406   }
 407 }
 408
 409 bool BluetoothTaskManagerWin::SearchDevices(
 410     int timeout_multiplier,
 411     bool search_cached_devices_only,
 412     ScopedVector<DeviceState>* device_list) {
 413   return SearchClassicDevices(
 414              timeout_multiplier, search_cached_devices_only, device_list) &&
 415          SearchLowEnergyDevices(device_list) &&
 416          DiscoverServices(device_list, search_cached_devices_only);
 417 }
 418
 419 bool BluetoothTaskManagerWin::SearchClassicDevices(
 420     int timeout_multiplier,
 421     bool search_cached_devices_only,
 422     ScopedVector<DeviceState>* device_list) {
 423   // Issues a device inquiry and waits for |timeout_multiplier| * 1.28 seconds.
 424   BLUETOOTH_DEVICE_SEARCH_PARAMS device_search_params;
 425   ZeroMemory(&device_search_params, sizeof(device_search_params));
 426   device_search_params.dwSize = sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS);
 427   device_search_params.fReturnAuthenticated = 1;
 428   device_search_params.fReturnRemembered = 1;
 429   device_search_params.fReturnUnknown = (search_cached_devices_only ? 0 : 1);
 430   device_search_params.fReturnConnected = 1;
 431   device_search_params.fIssueInquiry = (search_cached_devices_only ? 0 : 1);
 432   device_search_params.cTimeoutMultiplier = timeout_multiplier;
 433
 434   BLUETOOTH_DEVICE_INFO device_info;
 435   ZeroMemory(&device_info, sizeof(device_info));
 436   device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
 437   HBLUETOOTH_DEVICE_FIND handle =
 438       BluetoothFindFirstDevice(&device_search_params, &device_info);
 439   if (!handle) {
 440     int last_error = GetLastError();
 441     if (last_error == ERROR_NO_MORE_ITEMS) {
 442       return true;  // No devices is not an error.
 443     }
 444     LogPollingError("Error calling BluetoothFindFirstDevice", last_error);
 445     return false;
 446   }
 447
 448   while (true) {
 449     DeviceState* device_state = new DeviceState();
 450     GetDeviceState(device_info, device_state);
 451     device_list->push_back(device_state);
 452
 453     // Reset device info before next call (as a safety precaution).
 454     ZeroMemory(&device_info, sizeof(device_info));
 455     device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
 456     if (!BluetoothFindNextDevice(handle, &device_info)) {
 457       int last_error = GetLastError();
 458       if (last_error == ERROR_NO_MORE_ITEMS) {
 459         break;  // No more items is expected error when done enumerating.
 460       }
 461       LogPollingError("Error calling BluetoothFindNextDevice", last_error);
 462       BluetoothFindDeviceClose(handle);
 463       return false;
 464     }
 465   }
 466
 467   if (!BluetoothFindDeviceClose(handle)) {
 468     LogPollingError("Error calling BluetoothFindDeviceClose", GetLastError());
 469     return false;
 470   }
 471   return true;
 472 }
 473
 474 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
 475     ScopedVector<DeviceState>* device_list) {
 476   if (!win::IsBluetoothLowEnergySupported())
 477     return true;  // Bluetooth LE not supported is not an error.
 478
 479   ScopedVector<win::BluetoothLowEnergyDeviceInfo> btle_devices;
 480   std::string error;
 481   bool success =
 482       win::EnumerateKnownBluetoothLowEnergyDevices(&btle_devices, &error);
 483   if (!success) {
 484     LogPollingError(error.c_str(), 0);
 485     return false;
 486   }
 487
 488   for (ScopedVector<win::BluetoothLowEnergyDeviceInfo>::iterator iter =
 489            btle_devices.begin();
 490        iter != btle_devices.end();
 491        ++iter) {
 492     win::BluetoothLowEnergyDeviceInfo* device_info = (*iter);
 493     DeviceState* device_state = new DeviceState();
 494     device_state->name = device_info->friendly_name;
 495     device_state->address =
 496         BluetoothAddressToCanonicalString(device_info->address);
 497     device_state->visible = device_info->visible;
 498     device_state->authenticated = device_info->authenticated;
 499     device_state->connected = device_info->connected;
 500     device_state->path = device_info->path;
 501     device_list->push_back(device_state);
 502   }
 503   return true;
 504 }
 505
 506 bool BluetoothTaskManagerWin::DiscoverServices(
 507     ScopedVector<DeviceState>* device_list,
 508     bool search_cached_services_only) {
 509   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 510   net::EnsureWinsockInit();
 511   for (ScopedVector<DeviceState>::iterator iter = device_list->begin();
 512       iter != device_list->end();
 513       ++iter) {
 514     DeviceState* device = (*iter);
 515     ScopedVector<ServiceRecordState>* service_record_states =
 516         &(*iter)->service_record_states;
 517
 518     if ((*iter)->is_bluetooth_classic()) {
 519       if (!DiscoverClassicDeviceServices(device->address,
 520                                          L2CAP_PROTOCOL_UUID,
 521                                          search_cached_services_only,
 522                                          service_record_states)) {
 523         return false;
 524       }
 525     } else {
 526       if (!DiscoverLowEnergyDeviceServices(device->path,
 527                                            service_record_states)) {
 528         return false;
 529       }
 530     }
 531   }
 532   return true;
 533 }
 534
 535 bool BluetoothTaskManagerWin::DiscoverClassicDeviceServices(
 536     const std::string& device_address,
 537     const GUID& protocol_uuid,
 538     bool search_cached_services_only,
 539     ScopedVector<ServiceRecordState>* service_record_states) {
 540   int error_code =
 541       DiscoverClassicDeviceServicesWorker(device_address,
 542                                           protocol_uuid,
 543                                           search_cached_services_only,
 544                                           service_record_states);
 545   // If the device is "offline", no services are returned when specifying
 546   // "LUP_FLUSHCACHE". Try again without flushing the cache so that the list
 547   // of previously known services is returned.
 548   if (!search_cached_services_only &&
 549       (error_code == WSASERVICE_NOT_FOUND || error_code == WSANO_DATA)) {
 550     error_code = DiscoverClassicDeviceServicesWorker(
 551         device_address, protocol_uuid, true, service_record_states);
 552   }
 553
 554   return (error_code == ERROR_SUCCESS);
 555 }
 556
 557 int BluetoothTaskManagerWin::DiscoverClassicDeviceServicesWorker(
 558     const std::string& device_address,
 559     const GUID& protocol_uuid,
 560     bool search_cached_services_only,
 561     ScopedVector<ServiceRecordState>* service_record_states) {
 562   // Bluetooth and WSAQUERYSET for Service Inquiry. See http://goo.gl/2v9pyt.
 563   WSAQUERYSET sdp_query;
 564   ZeroMemory(&sdp_query, sizeof(sdp_query));
 565   sdp_query.dwSize = sizeof(sdp_query);
 566   GUID protocol = protocol_uuid;
 567   sdp_query.lpServiceClassId = &protocol;
 568   sdp_query.dwNameSpace = NS_BTH;
 569   wchar_t device_address_context[kMaxNumDeviceAddressChar];
 570   std::size_t length = base::SysUTF8ToWide("(" + device_address + ")").copy(
 571       device_address_context, kMaxNumDeviceAddressChar);
 572   device_address_context[length] = NULL;
 573   sdp_query.lpszContext = device_address_context;
 574   DWORD control_flags = LUP_RETURN_ALL;
 575   // See http://goo.gl/t1Hulo: "Applications should generally specify
 576   // LUP_FLUSHCACHE. This flag instructs the system to ignore any cached
 577   // information and establish an over-the-air SDP connection to the specified
 578   // device to perform the SDP search. This non-cached operation may take
 579   // several seconds (whereas a cached search returns quickly)."
 580   // In summary, we need to specify LUP_FLUSHCACHE if we want to obtain the list
 581   // of services for devices which have not been discovered before.
 582   if (!search_cached_services_only)
 583     control_flags |= LUP_FLUSHCACHE;
 584   HANDLE sdp_handle;
 585   if (ERROR_SUCCESS !=
 586       WSALookupServiceBegin(&sdp_query, control_flags, &sdp_handle)) {
 587     int last_error = WSAGetLastError();
 588     // If the device is "offline", no services are returned when specifying
 589     // "LUP_FLUSHCACHE". Don't log error in that case.
 590     if (!search_cached_services_only &&
 591         (last_error == WSASERVICE_NOT_FOUND || last_error == WSANO_DATA)) {
 592       return last_error;
 593     }
 594     LogPollingError("Error calling WSALookupServiceBegin", last_error);
 595     return last_error;
 596   }
 597   char sdp_buffer[kServiceDiscoveryResultBufferSize];
 598   LPWSAQUERYSET sdp_result_data = reinterpret_cast<LPWSAQUERYSET>(sdp_buffer);
 599   while (true) {
 600     DWORD sdp_buffer_size = sizeof(sdp_buffer);
 601     if (ERROR_SUCCESS !=
 602         WSALookupServiceNext(
 603             sdp_handle, control_flags, &sdp_buffer_size, sdp_result_data)) {
 604       int last_error = WSAGetLastError();
 605       if (last_error == WSA_E_NO_MORE || last_error == WSAENOMORE) {
 606         break;
 607       }
 608       LogPollingError("Error calling WSALookupServiceNext", last_error);
 609       WSALookupServiceEnd(sdp_handle);
 610       return last_error;
 611     }
 612     ServiceRecordState* service_record_state = new ServiceRecordState();
 613     service_record_state->name =
 614         base::SysWideToUTF8(sdp_result_data->lpszServiceInstanceName);
 615     for (uint64 i = 0; i < sdp_result_data->lpBlob->cbSize; i++) {
 616       service_record_state->sdp_bytes.push_back(
 617           sdp_result_data->lpBlob->pBlobData[i]);
 618     }
 619     service_record_states->push_back(service_record_state);
 620   }
 621   if (ERROR_SUCCESS != WSALookupServiceEnd(sdp_handle)) {
 622     int last_error = WSAGetLastError();
 623     LogPollingError("Error calling WSALookupServiceEnd", last_error);
 624     return last_error;
 625   }
 626
 627   return ERROR_SUCCESS;
 628 }
 629
 630 bool BluetoothTaskManagerWin::DiscoverLowEnergyDeviceServices(
 631     const base::FilePath& device_path,
 632     ScopedVector<ServiceRecordState>* service_record_states) {
 633   if (!win::IsBluetoothLowEnergySupported())
 634     return true;  // Bluetooth LE not supported is not an error.
 635
 636   std::string error;
 637   ScopedVector<win::BluetoothLowEnergyServiceInfo> services;
 638   bool success = win::EnumerateKnownBluetoothLowEnergyServices(
 639       device_path, &services, &error);
 640   if (!success) {
 641     LogPollingError(error.c_str(), 0);
 642     return false;
 643   }
 644
 645   for (ScopedVector<win::BluetoothLowEnergyServiceInfo>::iterator iter2 =
 646            services.begin();
 647        iter2 != services.end();
 648        ++iter2) {
 649     ServiceRecordState* service_state = new ServiceRecordState();
 650     service_state->gatt_uuid =
 651         BluetoothLowEnergyUuidToBluetoothUuid((*iter2)->uuid);
 652     service_record_states->push_back(service_state);
 653   }
 654   return true;
 655 }
 656
 657 }  // namespace device