Refactor bluetooth_low_energy_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>
@@ skipping 124 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();
 }
 
 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
   DCHECK(observer);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   observers_.AddObserver(observer);
 }
 
 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
   DCHECK(observer);
@@ skipping 318 matching lines @@
 }
 
 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
     ScopedVector<DeviceState>* device_list) {
   if (!win::IsBluetoothLowEnergySupported())
     return true;  // Bluetooth LE not supported is not an error.
 
   ScopedVector<win::BluetoothLowEnergyDeviceInfo> btle_devices;
   std::string error;
   bool success =
-      win::EnumerateKnownBluetoothLowEnergyDevices(&btle_devices, &error);
+      win::BluetoothLowEnergyWrapper::GetInstance()
+          ->EnumerateKnownBluetoothLowEnergyDevices(&btle_devices, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
   for (ScopedVector<win::BluetoothLowEnergyDeviceInfo>::iterator iter =
            btle_devices.begin();
        iter != btle_devices.end();
        ++iter) {
     win::BluetoothLowEnergyDeviceInfo* device_info = (*iter);
@@ skipping 136 matching lines @@
 }
 
 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;
-  bool success = win::EnumerateKnownBluetoothLowEnergyServices(
-      device_path, &services, &error);
+  bool success = win::BluetoothLowEnergyWrapper::GetInstance()
+                     ->EnumerateKnownBluetoothLowEnergyServices(
+                         device_path, &services, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
   for (ScopedVector<win::BluetoothLowEnergyServiceInfo>::iterator iter2 =
            services.begin();
        iter2 != services.end();
        ++iter2) {
     ServiceRecordState* service_state = new ServiceRecordState();
@@ skipping 10 matching lines @@
 // lists all GATT service devices and matches them back to correspond GATT
 // service of the BLE device according to their address and included service
 // attribute handles, as we did not find a more neat way to bond them.
 bool BluetoothTaskManagerWin::SearchForGattServiceDevicePaths(
     const std::string device_address,
     ScopedVector<ServiceRecordState>* service_record_states) {
   std::string error;
 
   // List all known GATT service devices on the machine.
   ScopedVector<win::BluetoothLowEnergyDeviceInfo> gatt_service_devices;
-  bool success = win::EnumerateKnownBluetoothLowEnergyGattServiceDevices(
-      &gatt_service_devices, &error);
+  bool success = win::BluetoothLowEnergyWrapper::GetInstance()
+                     ->EnumerateKnownBluetoothLowEnergyGattServiceDevices(
+                         &gatt_service_devices, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
   for (auto gatt_service_device : gatt_service_devices) {
     // Only care about the service devices with |device_address|.
     if (BluetoothAddressToCanonicalString(gatt_service_device->address) !=
         device_address) {
       continue;
     }
 
     // Discover this service device's contained services.
     ScopedVector<win::BluetoothLowEnergyServiceInfo> gatt_services;
-    if (!win::EnumerateKnownBluetoothLowEnergyServices(
-            gatt_service_device->path, &gatt_services, &error)) {
+    if (!win::BluetoothLowEnergyWrapper::GetInstance()
+             ->EnumerateKnownBluetoothLowEnergyServices(
+                 gatt_service_device->path, &gatt_services, &error)) {
       LogPollingError(error.c_str(), 0);
       continue;
     }
 
     // Usually each service device correspond to one Gatt service.
     if (gatt_services.size() > 1) {
       LOG(WARNING) << "This GATT service device contains more than one ("
                    << gatt_services.size() << ") services";
     }
 
     // Associate service device to corresponding service record. Attribute
     // handle is unique on one device.
     for (auto gatt_service : gatt_services) {
       for (auto service_record_state : *service_record_states) {
         if (service_record_state->attribute_handle ==
             gatt_service->attribute_handle) {
           service_record_state->path = gatt_service_device->path;
           break;
         }
       }
     }
   }
 
   return true;
 }
 
 }  // namespace device