Fix Bluetooth Classic device polling issue.

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 519 matching lines @@
     }
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::DiscoverClassicDeviceServices(
     const std::string& device_address,
     const GUID& protocol_uuid,
     bool search_cached_services_only,
     ScopedVector<ServiceRecordState>* service_record_states) {
+  int error_code =
+      DiscoverClassicDeviceServicesWorker(device_address,
+                                          protocol_uuid,
+                                          search_cached_services_only,
+                                          service_record_states);
+  // If the device is "offline", no services are returned when specifying
+  // "LUP_FLUSHCACHE". Try again without flushing the cache so that the list
+  // of previously known services is returned.
+  if (!search_cached_services_only &&
+      (error_code == WSASERVICE_NOT_FOUND || error_code == WSANO_DATA)) {
+    error_code = DiscoverClassicDeviceServicesWorker(
+        device_address, protocol_uuid, true, service_record_states);
+  }
+
+  return (error_code == ERROR_SUCCESS);
+}
+
+int BluetoothTaskManagerWin::DiscoverClassicDeviceServicesWorker(
+    const std::string& device_address,
+    const GUID& protocol_uuid,
+    bool search_cached_services_only,
+    ScopedVector<ServiceRecordState>* service_record_states) {
   // Bluetooth and WSAQUERYSET for Service Inquiry. See http://goo.gl/2v9pyt.
   WSAQUERYSET sdp_query;
   ZeroMemory(&sdp_query, sizeof(sdp_query));
   sdp_query.dwSize = sizeof(sdp_query);
   GUID protocol = protocol_uuid;
   sdp_query.lpServiceClassId = &protocol;
   sdp_query.dwNameSpace = NS_BTH;
   wchar_t device_address_context[kMaxNumDeviceAddressChar];
   std::size_t length = base::SysUTF8ToWide("(" + device_address + ")").copy(
       device_address_context, kMaxNumDeviceAddressChar);
   device_address_context[length] = NULL;
   sdp_query.lpszContext = device_address_context;
   DWORD control_flags = LUP_RETURN_ALL;
   // See http://goo.gl/t1Hulo: "Applications should generally specify
   // LUP_FLUSHCACHE. This flag instructs the system to ignore any cached
   // information and establish an over-the-air SDP connection to the specified
   // device to perform the SDP search. This non-cached operation may take
   // several seconds (whereas a cached search returns quickly)."
   // In summary, we need to specify LUP_FLUSHCACHE if we want to obtain the list
   // of services for devices which have not been discovered before.
   if (!search_cached_services_only)
     control_flags |= LUP_FLUSHCACHE;
   HANDLE sdp_handle;
   if (ERROR_SUCCESS !=
       WSALookupServiceBegin(&sdp_query, control_flags, &sdp_handle)) {
-    LogPollingError("Error calling WSALookupServiceBegin", WSAGetLastError());
-    return false;
+    int last_error = WSAGetLastError();
+    // If the device is "offline", no services are returned when specifying
+    // "LUP_FLUSHCACHE". Don't log error in that case.
+    if (!search_cached_services_only &&
+        (last_error == WSASERVICE_NOT_FOUND || last_error == WSANO_DATA)) {
+      return last_error;
+    }
+    LogPollingError("Error calling WSALookupServiceBegin", last_error);
+    return last_error;
   }
   char sdp_buffer[kServiceDiscoveryResultBufferSize];
   LPWSAQUERYSET sdp_result_data = reinterpret_cast<LPWSAQUERYSET>(sdp_buffer);
   while (true) {
     DWORD sdp_buffer_size = sizeof(sdp_buffer);
     if (ERROR_SUCCESS !=
         WSALookupServiceNext(
             sdp_handle, control_flags, &sdp_buffer_size, sdp_result_data)) {
       int last_error = WSAGetLastError();
       if (last_error == WSA_E_NO_MORE || last_error == WSAENOMORE) {
         break;
       }
       LogPollingError("Error calling WSALookupServiceNext", last_error);
       WSALookupServiceEnd(sdp_handle);
-      return false;
+      return last_error;
     }
     ServiceRecordState* service_record_state = new ServiceRecordState();
     service_record_state->name =
         base::SysWideToUTF8(sdp_result_data->lpszServiceInstanceName);
     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);
   }
   if (ERROR_SUCCESS != WSALookupServiceEnd(sdp_handle)) {
-    LogPollingError("Error calling WSALookupServiceEnd", WSAGetLastError());
-    return false;
+    int last_error = WSAGetLastError();
+    LogPollingError("Error calling WSALookupServiceEnd", last_error);
+    return last_error;
   }
 
-  return true;
+  return ERROR_SUCCESS;
 }
 
 bool BluetoothTaskManagerWin::DiscoverLowEnergyDeviceServices(
     const base::FilePath& device_path,
     ScopedVector<ServiceRecordState>* service_record_states) {
   if (!win::IsBluetoothLowEnergySupported())
     return true;  // Bluetooth LE not supported is not an error.
 
   std::string error;
   ScopedVector<win::BluetoothLowEnergyServiceInfo> services;
@@ skipping 10 matching lines @@
        ++iter2) {
     ServiceRecordState* service_state = new ServiceRecordState();
     service_state->gatt_uuid =
         BluetoothLowEnergyUuidToBluetoothUuid((*iter2)->uuid);
     service_record_states->push_back(service_state);
   }
   return true;
 }
 
 }  // namespace device