Refactor bluetooth_task_manager_win to prepare for new Bluetooth test fixture

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 "base/win/scoped_handle.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";
@@ skipping 47 matching lines @@
 }
 
 // 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 &&
-      ERROR_SUCCESS == BluetoothGetRadioInfo(adapter_handle,
-                                             &adapter_info)) {
+      ERROR_SUCCESS ==
+          device::win::BluetoothClassicWrapper::GetInstance()->GetRadioInfo(
+              adapter_handle, &adapter_info)) {
     name = base::SysWideToUTF8(adapter_info.szName);
     address = BluetoothAddressToCanonicalString(adapter_info.address);
-    powered = !!BluetoothIsConnectable(adapter_handle);
+    powered =
+        !!device::win::BluetoothClassicWrapper::GetInstance()->IsConnectable(
+            adapter_handle);
   }
   state->name = name;
   state->address = address;
   state->powered = powered;
 }
 
 void GetDeviceState(const BLUETOOTH_DEVICE_INFO& device_info,
                     device::BluetoothTaskManagerWin::DeviceState* state) {
   state->name = base::SysWideToUTF8(device_info.szName);
   state->address = BluetoothAddressToCanonicalString(device_info.Address);
@@ skipping 34 matching lines @@
 
 BluetoothTaskManagerWin::BluetoothTaskManagerWin(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
     : ui_task_runner_(ui_task_runner),
       discovering_(false),
       current_logging_batch_count_(0) {
 }
 
 BluetoothTaskManagerWin::~BluetoothTaskManagerWin() {
   win::BluetoothLowEnergyWrapper::DeleteInstance();
+  win::BluetoothClassicWrapper::DeleteInstance();
 }
 
 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
   DCHECK(observer);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   observers_.AddObserver(observer);
 }
 
 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
   DCHECK(observer);
@@ skipping 132 matching lines @@
 void BluetoothTaskManagerWin::PollAdapter() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 
   // Skips updating the adapter info if the adapter is in discovery mode.
   if (!discovering_) {
     const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
         { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
     if (adapter_handle_.IsValid())
       adapter_handle_.Close();
     HANDLE temp_adapter_handle;
-    HBLUETOOTH_RADIO_FIND handle = BluetoothFindFirstRadio(
-        &adapter_param, &temp_adapter_handle);
+    HBLUETOOTH_RADIO_FIND handle =
+        win::BluetoothClassicWrapper::GetInstance()->FindFirstRadio(
+            &adapter_param, &temp_adapter_handle);
 
     if (handle) {
       adapter_handle_.Set(temp_adapter_handle);
       GetKnownDevices();
-      BluetoothFindRadioClose(handle);
+      win::BluetoothClassicWrapper::GetInstance()->FindRadioClose(handle);
     }
 
     PostAdapterStateToUi();
   }
 
   // Re-poll.
   bluetooth_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::PollAdapter,
                  this),
@@ skipping 11 matching lines @@
                  base::Owned(state)));
 }
 
 void BluetoothTaskManagerWin::SetPowered(
     bool powered,
     const base::Closure& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   bool success = false;
   if (adapter_handle_.IsValid()) {
-    if (!powered)
-      BluetoothEnableDiscovery(adapter_handle_.Get(), false);
-    success =
-        !!BluetoothEnableIncomingConnections(adapter_handle_.Get(), powered);
+    if (!powered) {
+      win::BluetoothClassicWrapper::GetInstance()->EnableDiscovery(
+          adapter_handle_.Get(), false);
+    }
+    success = !!win::BluetoothClassicWrapper::GetInstance()
+                    ->EnableIncomingConnections(adapter_handle_.Get(), powered);
   }
 
   if (success) {
     PostAdapterStateToUi();
     ui_task_runner_->PostTask(FROM_HERE, callback);
   } else {
     ui_task_runner_->PostTask(FROM_HERE, error_callback);
   }
 }
 
@@ skipping 80 matching lines @@
   device_search_params.fReturnRemembered = 1;
   device_search_params.fReturnUnknown = (search_cached_devices_only ? 0 : 1);
   device_search_params.fReturnConnected = 1;
   device_search_params.fIssueInquiry = (search_cached_devices_only ? 0 : 1);
   device_search_params.cTimeoutMultiplier = timeout_multiplier;
 
   BLUETOOTH_DEVICE_INFO device_info;
   ZeroMemory(&device_info, sizeof(device_info));
   device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
   HBLUETOOTH_DEVICE_FIND handle =
-      BluetoothFindFirstDevice(&device_search_params, &device_info);
+      win::BluetoothClassicWrapper::GetInstance()->FindFirstDevice(
+          &device_search_params, &device_info);
   if (!handle) {
     int last_error = GetLastError();
     if (last_error == ERROR_NO_MORE_ITEMS) {
       return true;  // No devices is not an error.
     }
     LogPollingError("Error calling BluetoothFindFirstDevice", last_error);
     return false;
   }
 
   while (true) {
     DeviceState* device_state = new DeviceState();
     GetDeviceState(device_info, device_state);
     device_list->push_back(device_state);
 
     // Reset device info before next call (as a safety precaution).
     ZeroMemory(&device_info, sizeof(device_info));
     device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
-    if (!BluetoothFindNextDevice(handle, &device_info)) {
+    if (!win::BluetoothClassicWrapper::GetInstance()->FindNextDevice(
+            handle, &device_info)) {
       int last_error = GetLastError();
       if (last_error == ERROR_NO_MORE_ITEMS) {
         break;  // No more items is expected error when done enumerating.
       }
       LogPollingError("Error calling BluetoothFindNextDevice", last_error);
-      BluetoothFindDeviceClose(handle);
+      win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle);
       return false;
     }
   }
 
-  if (!BluetoothFindDeviceClose(handle)) {
+  if (!win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle)) {
     LogPollingError("Error calling BluetoothFindDeviceClose", GetLastError());
     return false;
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
     ScopedVector<DeviceState>* device_list) {
   if (!win::IsBluetoothLowEnergySupported())
     return true;  // Bluetooth LE not supported is not an error.
@@ skipping 232 matching lines @@
           break;
         }
       }
     }
   }
 
   return true;
 }
 
 }  // namespace device