Remove global wrapper objects for Bluetooth Classic and LE

Having these API wrapper objects be globals is dangerous because each
BluetoothTaskManagerWin creates a new task runner on which to run
Bluetooth tasks. Since this is the only class that uses these objects
it can just own them instead.

To simplify things the weak HANDLE reference in BluetoothTaskManagerWin
has also been removed.

Bug: 820864
Change-Id: I2abaca53c1b7388503e0f18ac6a004426f0e95ac
Reviewed-on: https://chromium-review.googlesource.com/1117445
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Giovanni Ortuño Urquidi <ortuno@chromium.org>
Cr-Commit-Position: refs/heads/master@{#575015}

device/bluetooth/bluetooth_adapter_win.cc

@@ -19,6 +19,7 @@
 #include "base/win/windows_version.h"
 #include "device/base/features.h"
 #include "device/bluetooth/bluetooth_adapter_winrt.h"
+#include "device/bluetooth/bluetooth_classic_win.h"
 #include "device/bluetooth/bluetooth_device_win.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
@@ -354,19 +355,21 @@ void BluetoothAdapterWin::Init() {
   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   socket_thread_ = BluetoothSocketThread::Get();
   task_manager_ =
-      new BluetoothTaskManagerWin(ui_task_runner_);
+      base::MakeRefCounted<BluetoothTaskManagerWin>(ui_task_runner_);
   task_manager_->AddObserver(this);
   task_manager_->Initialize();
 }
 
 void BluetoothAdapterWin::InitForTest(
+    std::unique_ptr<win::BluetoothClassicWrapper> classic_wrapper,
+    std::unique_ptr<win::BluetoothLowEnergyWrapper> le_wrapper,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
   ui_task_runner_ = ui_task_runner;
   if (!ui_task_runner_)
     ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  task_manager_ =
-      new BluetoothTaskManagerWin(ui_task_runner_);
+  task_manager_ = BluetoothTaskManagerWin::CreateForTesting(
+      std::move(classic_wrapper), std::move(le_wrapper), ui_task_runner_);
   task_manager_->AddObserver(this);
   task_manager_->InitializeWithBluetoothTaskRunner(bluetooth_task_runner);
 }

device/bluetooth/bluetooth_adapter_win.h

@@ -129,6 +129,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterWin
 
   void Init();
   void InitForTest(
+      std::unique_ptr<win::BluetoothClassicWrapper> classic_wrapper,
+      std::unique_ptr<win::BluetoothLowEnergyWrapper> le_wrapper,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
       scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner);
 

device/bluetooth/bluetooth_adapter_win_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/test/test_simple_task_runner.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
+#include "device/bluetooth/bluetooth_classic_win.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
@@ -57,7 +58,8 @@ class BluetoothAdapterWinTest : public testing::Test {
         adapter_win_(static_cast<BluetoothAdapterWin*>(adapter_.get())),
         observer_(adapter_),
         init_callback_called_(false) {
-    adapter_win_->InitForTest(ui_task_runner_, bluetooth_task_runner_);
+    adapter_win_->InitForTest(nullptr, nullptr, ui_task_runner_,
+                              bluetooth_task_runner_);
   }
 
   void SetUp() override {

device/bluetooth/bluetooth_classic_win.cc

@@ -4,74 +4,37 @@
 
 #include "device/bluetooth/bluetooth_classic_win.h"
 
-namespace {
-static device::win::BluetoothClassicWrapper* g_instance_ = nullptr;
-}  // namespace
-
 namespace device {
 namespace win {
 
-BluetoothClassicWrapper* BluetoothClassicWrapper::GetInstance() {
-  if (g_instance_ == nullptr) {
-    g_instance_ = new BluetoothClassicWrapper();
-  }
-  return g_instance_;
-}
-
-void BluetoothClassicWrapper::DeleteInstance() {
-  delete g_instance_;
-  g_instance_ = nullptr;
-}
-
-void BluetoothClassicWrapper::SetInstanceForTest(
-    BluetoothClassicWrapper* instance) {
-  delete g_instance_;
-  g_instance_ = instance;
-}
-
 BluetoothClassicWrapper::BluetoothClassicWrapper() {}
 BluetoothClassicWrapper::~BluetoothClassicWrapper() {}
 
 HBLUETOOTH_RADIO_FIND BluetoothClassicWrapper::FindFirstRadio(
-    const BLUETOOTH_FIND_RADIO_PARAMS* params,
-    HANDLE* out_handle) {
+    const BLUETOOTH_FIND_RADIO_PARAMS* params) {
   HANDLE radio_handle = INVALID_HANDLE_VALUE;
   HBLUETOOTH_RADIO_FIND radio_find_handle =
       BluetoothFindFirstRadio(params, &radio_handle);
   if (radio_find_handle) {
-    // TODO(crbug.com/820864): At some point, we crash when we attempt to close
-    // the handle.  This and the related checks in this file are designed to
-    // see if our handle becomes garbage (i.e., "valid", but not closeable) at
-    // some point.
-    DWORD info;
-    CHECK(!base::win::HandleTraits::IsHandleValid(radio_handle) ||
-          ::GetHandleInformation(radio_handle, &info));
+    DCHECK_NE(radio_handle, INVALID_HANDLE_VALUE);
     opened_radio_handle_.Set(radio_handle);
-    *out_handle = opened_radio_handle_.Get();
   }
   return radio_find_handle;
 }
 
 DWORD BluetoothClassicWrapper::GetRadioInfo(
-    HANDLE handle,
     PBLUETOOTH_RADIO_INFO out_radio_info) {
-  DWORD ret = BluetoothGetRadioInfo(handle, out_radio_info);
-  DWORD info;
-  // TODO(crbug.com/820864): Remove this check.
-  CHECK(::GetHandleInformation(handle, &info));
-  return ret;
+  DCHECK(opened_radio_handle_.IsValid());
+  return BluetoothGetRadioInfo(opened_radio_handle_.Get(), out_radio_info);
 }
 
 BOOL BluetoothClassicWrapper::FindRadioClose(HBLUETOOTH_RADIO_FIND handle) {
   return BluetoothFindRadioClose(handle);
 }
 
-BOOL BluetoothClassicWrapper::IsConnectable(HANDLE handle) {
-  DWORD ret = BluetoothIsConnectable(handle);
-  DWORD info;
-  // TODO(crbug.com/820864): Remove this check.
-  CHECK(::GetHandleInformation(handle, &info));
-  return ret;
+BOOL BluetoothClassicWrapper::IsConnectable() {
+  DCHECK(opened_radio_handle_.IsValid());
+  return BluetoothIsConnectable(opened_radio_handle_.Get());
 }
 
 HBLUETOOTH_DEVICE_FIND BluetoothClassicWrapper::FindFirstDevice(
@@ -90,26 +53,24 @@ BOOL BluetoothClassicWrapper::FindDeviceClose(HBLUETOOTH_DEVICE_FIND handle) {
   return BluetoothFindDeviceClose(handle);
 }
 
-BOOL BluetoothClassicWrapper::EnableDiscovery(HANDLE handle, BOOL is_enable) {
-  DWORD ret = BluetoothEnableDiscovery(handle, is_enable);
-  DWORD info;
-  // TODO(crbug.com/820864): Remove this check.
-  CHECK(::GetHandleInformation(handle, &info));
-  return ret;
+BOOL BluetoothClassicWrapper::EnableDiscovery(BOOL is_enable) {
+  DCHECK(opened_radio_handle_.IsValid());
+  return BluetoothEnableDiscovery(opened_radio_handle_.Get(), is_enable);
 }
 
-BOOL BluetoothClassicWrapper::EnableIncomingConnections(HANDLE handle,
-                                                        BOOL is_enable) {
-  DWORD ret = BluetoothEnableIncomingConnections(handle, is_enable);
-  DWORD info;
-  // TODO(crbug.com/820864): Remove this check.
-  CHECK(::GetHandleInformation(handle, &info));
-  return ret;
+BOOL BluetoothClassicWrapper::EnableIncomingConnections(BOOL is_enable) {
+  DCHECK(opened_radio_handle_.IsValid());
+  return BluetoothEnableIncomingConnections(opened_radio_handle_.Get(),
+                                            is_enable);
 }
 
 DWORD BluetoothClassicWrapper::LastError() {
   return GetLastError();
 }
 
+bool BluetoothClassicWrapper::HasHandle() {
+  return opened_radio_handle_.IsValid();
+}
+
 }  // namespace win
 }  // namespace device

device/bluetooth/bluetooth_classic_win.h

@@ -17,30 +17,24 @@ namespace win {
 // tests.
 class DEVICE_BLUETOOTH_EXPORT BluetoothClassicWrapper {
  public:
-  static BluetoothClassicWrapper* GetInstance();
-  static void DeleteInstance();
-  static void SetInstanceForTest(BluetoothClassicWrapper* instance);
+  BluetoothClassicWrapper();
+  virtual ~BluetoothClassicWrapper();
 
   virtual HBLUETOOTH_RADIO_FIND FindFirstRadio(
-      const BLUETOOTH_FIND_RADIO_PARAMS* params,
-      HANDLE* out_handle);
-  virtual DWORD GetRadioInfo(HANDLE handle,
-                             PBLUETOOTH_RADIO_INFO out_radio_info);
+      const BLUETOOTH_FIND_RADIO_PARAMS* params);
+  virtual DWORD GetRadioInfo(PBLUETOOTH_RADIO_INFO out_radio_info);
   virtual BOOL FindRadioClose(HBLUETOOTH_RADIO_FIND handle);
-  virtual BOOL IsConnectable(HANDLE handle);
+  virtual BOOL IsConnectable();
   virtual HBLUETOOTH_DEVICE_FIND FindFirstDevice(
       const BLUETOOTH_DEVICE_SEARCH_PARAMS* params,
       BLUETOOTH_DEVICE_INFO* out_device_info);
   virtual BOOL FindNextDevice(HBLUETOOTH_DEVICE_FIND handle,
                               BLUETOOTH_DEVICE_INFO* out_device_info);
   virtual BOOL FindDeviceClose(HBLUETOOTH_DEVICE_FIND handle);
-  virtual BOOL EnableDiscovery(HANDLE handle, BOOL is_enable);
-  virtual BOOL EnableIncomingConnections(HANDLE handle, BOOL is_enable);
+  virtual BOOL EnableDiscovery(BOOL is_enable);
+  virtual BOOL EnableIncomingConnections(BOOL is_enable);
   virtual DWORD LastError();
-
- protected:
-  BluetoothClassicWrapper();
-  virtual ~BluetoothClassicWrapper();
+  virtual bool HasHandle();
 
  private:
   base::win::ScopedHandle opened_radio_handle_;

device/bluetooth/bluetooth_classic_win_fake.cc

@@ -14,19 +14,16 @@ BluetoothClassicWrapperFake::BluetoothClassicWrapperFake()
 BluetoothClassicWrapperFake::~BluetoothClassicWrapperFake() {}
 
 HBLUETOOTH_RADIO_FIND BluetoothClassicWrapperFake::FindFirstRadio(
-    const BLUETOOTH_FIND_RADIO_PARAMS* params,
-    HANDLE* out_handle) {
+    const BLUETOOTH_FIND_RADIO_PARAMS* params) {
   if (simulated_radios_) {
-    *out_handle = (PVOID)simulated_radios_.get();
     last_error_ = ERROR_SUCCESS;
-    return *out_handle;
+    return (PVOID)simulated_radios_.get();
   }
   last_error_ = ERROR_NO_MORE_ITEMS;
   return NULL;
 }
 
 DWORD BluetoothClassicWrapperFake::GetRadioInfo(
-    HANDLE handle,
     PBLUETOOTH_RADIO_INFO out_radio_info) {
   if (simulated_radios_) {
     *out_radio_info = simulated_radios_->radio_info;
@@ -38,10 +35,11 @@ DWORD BluetoothClassicWrapperFake::GetRadioInfo(
 }
 
 BOOL BluetoothClassicWrapperFake::FindRadioClose(HBLUETOOTH_RADIO_FIND handle) {
+  DCHECK_EQ(handle, (PVOID)simulated_radios_.get());
   return TRUE;
 }
 
-BOOL BluetoothClassicWrapperFake::IsConnectable(HANDLE handle) {
+BOOL BluetoothClassicWrapperFake::IsConnectable() {
   if (simulated_radios_) {
     last_error_ = ERROR_SUCCESS;
     return simulated_radios_->is_connectable;
@@ -69,13 +67,11 @@ BOOL BluetoothClassicWrapperFake::FindDeviceClose(
   return TRUE;
 }
 
-BOOL BluetoothClassicWrapperFake::EnableDiscovery(HANDLE handle,
-                                                  BOOL is_enable) {
+BOOL BluetoothClassicWrapperFake::EnableDiscovery(BOOL is_enable) {
   return TRUE;
 }
 
-BOOL BluetoothClassicWrapperFake::EnableIncomingConnections(HANDLE handle,
-                                                            BOOL is_enable) {
+BOOL BluetoothClassicWrapperFake::EnableIncomingConnections(BOOL is_enable) {
   return TRUE;
 }
 
@@ -83,6 +79,10 @@ DWORD BluetoothClassicWrapperFake::LastError() {
   return last_error_;
 }
 
+bool BluetoothClassicWrapperFake::HasHandle() {
+  return bool(simulated_radios_);
+}
+
 BluetoothRadio* BluetoothClassicWrapperFake::SimulateARadio(
     base::string16 name,
     BLUETOOTH_ADDRESS address) {

device/bluetooth/bluetooth_classic_win_fake.h

@@ -25,21 +25,20 @@ class BluetoothClassicWrapperFake : public BluetoothClassicWrapper {
   ~BluetoothClassicWrapperFake() override;
 
   HBLUETOOTH_RADIO_FIND FindFirstRadio(
-      const BLUETOOTH_FIND_RADIO_PARAMS* params,
-      HANDLE* out_handle) override;
-  DWORD GetRadioInfo(HANDLE handle,
-                     PBLUETOOTH_RADIO_INFO out_radio_info) override;
+      const BLUETOOTH_FIND_RADIO_PARAMS* params) override;
+  DWORD GetRadioInfo(PBLUETOOTH_RADIO_INFO out_radio_info) override;
   BOOL FindRadioClose(HBLUETOOTH_RADIO_FIND handle) override;
-  BOOL IsConnectable(HANDLE handle) override;
+  BOOL IsConnectable() override;
   HBLUETOOTH_DEVICE_FIND FindFirstDevice(
       const BLUETOOTH_DEVICE_SEARCH_PARAMS* params,
       BLUETOOTH_DEVICE_INFO* out_device_info) override;
   BOOL FindNextDevice(HBLUETOOTH_DEVICE_FIND handle,
                       BLUETOOTH_DEVICE_INFO* out_device_info) override;
   BOOL FindDeviceClose(HBLUETOOTH_DEVICE_FIND handle) override;
-  BOOL EnableDiscovery(HANDLE handle, BOOL is_enable) override;
-  BOOL EnableIncomingConnections(HANDLE handle, BOOL is_enable) override;
+  BOOL EnableDiscovery(BOOL is_enable) override;
+  BOOL EnableIncomingConnections(BOOL is_enable) override;
   DWORD LastError() override;
+  bool HasHandle() override;
 
   BluetoothRadio* SimulateARadio(base::string16 name,
                                  BLUETOOTH_ADDRESS address);

device/bluetooth/bluetooth_low_energy_win.cc

@@ -19,8 +19,6 @@
 
 namespace {
 
-static device::win::BluetoothLowEnergyWrapper* g_instance_ = nullptr;
-
 using device::win::DeviceRegistryPropertyValue;
 using device::win::DevicePropertyValue;
 using device::win::BluetoothLowEnergyDeviceInfo;
@@ -651,24 +649,6 @@ bool ExtractBluetoothAddressFromDeviceInstanceIdForTesting(
   return ExtractBluetoothAddressFromDeviceInstanceId(instance_id, btha, error);
 }
 
-BluetoothLowEnergyWrapper* BluetoothLowEnergyWrapper::GetInstance() {
-  if (g_instance_ == nullptr) {
-    g_instance_ = new BluetoothLowEnergyWrapper();
-  }
-  return g_instance_;
-}
-
-void BluetoothLowEnergyWrapper::DeleteInstance() {
-  delete g_instance_;
-  g_instance_ = nullptr;
-}
-
-void BluetoothLowEnergyWrapper::SetInstanceForTest(
-    BluetoothLowEnergyWrapper* instance) {
-  delete g_instance_;
-  g_instance_ = instance;
-}
-
 BluetoothLowEnergyWrapper::BluetoothLowEnergyWrapper() {}
 BluetoothLowEnergyWrapper::~BluetoothLowEnergyWrapper() {}
 

device/bluetooth/bluetooth_low_energy_win.h

@@ -121,9 +121,8 @@ ExtractBluetoothAddressFromDeviceInstanceIdForTesting(
 // interface that can be replaced with fakes in tests.
 class DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyWrapper {
  public:
-  static BluetoothLowEnergyWrapper* GetInstance();
-  static void DeleteInstance();
-  static void SetInstanceForTest(BluetoothLowEnergyWrapper* instance);
+  BluetoothLowEnergyWrapper();
+  virtual ~BluetoothLowEnergyWrapper();
 
   // Returns true only on Windows platforms supporting Bluetooth Low Energy.
   virtual bool IsBluetoothLowEnergySupported();
@@ -210,10 +209,6 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyWrapper {
   virtual HRESULT WriteDescriptorValue(base::FilePath& service_path,
                                        const PBTH_LE_GATT_DESCRIPTOR descriptor,
                                        PBTH_LE_GATT_DESCRIPTOR_VALUE new_value);
-
- protected:
-  BluetoothLowEnergyWrapper();
-  virtual ~BluetoothLowEnergyWrapper();
 };
 
 }  // namespace win

device/bluetooth/bluetooth_task_manager_win.h

@@ -29,6 +29,11 @@ class SequencedTaskRunner;
 
 namespace device {
 
+namespace win {
+class BluetoothClassicWrapper;
+class BluetoothLowEnergyWrapper;
+}  // namespace win
+
 // Manages the blocking Bluetooth tasks using |SequencedWorkerPool|. It runs
 // bluetooth tasks using |SequencedWorkerPool| and informs its observers of
 // bluetooth adapter state changes and any other bluetooth device inquiry
@@ -111,6 +116,11 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothTaskManagerWin
   explicit BluetoothTaskManagerWin(
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
 
+  static scoped_refptr<BluetoothTaskManagerWin> CreateForTesting(
+      std::unique_ptr<win::BluetoothClassicWrapper> classic_wrapper,
+      std::unique_ptr<win::BluetoothLowEnergyWrapper> le_wrapper,
+      scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
+
   static BluetoothUUID BluetoothLowEnergyUuidToBluetoothUuid(
       const BTH_LE_UUID& bth_le_uuid);
 
@@ -199,6 +209,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothTaskManagerWin
 
   static const int kPollIntervalMs;
 
+  BluetoothTaskManagerWin(
+      std::unique_ptr<win::BluetoothClassicWrapper> classic_wrapper,
+      std::unique_ptr<win::BluetoothLowEnergyWrapper> le_wrapper,
+      scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
   virtual ~BluetoothTaskManagerWin();
 
   // Logs Win32 errors occurring during polling on the worker thread. The method
@@ -321,16 +335,16 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothTaskManagerWin
   // List of observers interested in event notifications.
   base::ObserverList<Observer> observers_;
 
-  // Weak reference of the adapter handle, let BluetoothClassicWrapper handle
-  // the close of |adapter_handle_|.
-  HANDLE adapter_handle_;
-
   // indicates whether the adapter is in discovery mode or not.
-  bool discovering_;
+  bool discovering_ = false;
 
   // Use for discarding too many log messages.
   base::TimeTicks current_logging_batch_ticks_;
-  int current_logging_batch_count_;
+  int current_logging_batch_count_ = 0;
+
+  // Wrapper around the Windows Bluetooth APIs. Owns the radio handle.
+  std::unique_ptr<win::BluetoothClassicWrapper> classic_wrapper_;
+  std::unique_ptr<win::BluetoothLowEnergyWrapper> le_wrapper_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothTaskManagerWin);
 };

device/bluetooth/bluetooth_task_manager_win_unittest.cc

@@ -8,6 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/test/test_pending_task.h"
 #include "base/test/test_simple_task_runner.h"
+#include "device/bluetooth/bluetooth_classic_win.h"
 #include "device/bluetooth/bluetooth_init_win.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
 #include "testing/gtest/include/gtest/gtest.h"

device/bluetooth/test/bluetooth_test_win.cc

@@ -190,7 +190,6 @@ BTH_LE_UUID CanonicalStringToBTH_LE_UUID(base::StringPiece uuid) {
 BluetoothTestWin::BluetoothTestWin()
     : ui_task_runner_(new base::TestSimpleTaskRunner()),
       bluetooth_task_runner_(new base::TestSimpleTaskRunner()),
-      fake_bt_classic_wrapper_(nullptr),
       fake_bt_le_wrapper_(nullptr) {}
 BluetoothTestWin::~BluetoothTestWin() {}
 
@@ -210,23 +209,28 @@ void BluetoothTestWin::InitWithDefaultAdapter() {
 void BluetoothTestWin::InitWithoutDefaultAdapter() {
   auto adapter =
       base::WrapRefCounted(new BluetoothAdapterWin(base::DoNothing()));
-  adapter->InitForTest(ui_task_runner_, bluetooth_task_runner_);
+  adapter->InitForTest(nullptr, nullptr, ui_task_runner_,
+                       bluetooth_task_runner_);
   adapter_ = std::move(adapter);
 }
 
 void BluetoothTestWin::InitWithFakeAdapter() {
-  fake_bt_classic_wrapper_ = new win::BluetoothClassicWrapperFake();
-  fake_bt_le_wrapper_ = new win::BluetoothLowEnergyWrapperFake();
-  fake_bt_le_wrapper_->AddObserver(this);
-  win::BluetoothClassicWrapper::SetInstanceForTest(fake_bt_classic_wrapper_);
-  win::BluetoothLowEnergyWrapper::SetInstanceForTest(fake_bt_le_wrapper_);
-  fake_bt_classic_wrapper_->SimulateARadio(
+  auto fake_bt_classic_wrapper =
+      std::make_unique<win::BluetoothClassicWrapperFake>();
+  fake_bt_classic_wrapper->SimulateARadio(
       base::SysUTF8ToWide(kTestAdapterName),
       CanonicalStringToBLUETOOTH_ADDRESS(kTestAdapterAddress));
 
+  auto fake_bt_le_wrapper =
+      std::make_unique<win::BluetoothLowEnergyWrapperFake>();
+  fake_bt_le_wrapper_ = fake_bt_le_wrapper.get();
+  fake_bt_le_wrapper_->AddObserver(this);
+
   auto adapter =
       base::WrapRefCounted(new BluetoothAdapterWin(base::DoNothing()));
-  adapter->InitForTest(nullptr, bluetooth_task_runner_);
+  adapter->InitForTest(std::move(fake_bt_classic_wrapper),
+                       std::move(fake_bt_le_wrapper), nullptr,
+                       bluetooth_task_runner_);
   adapter_ = std::move(adapter);
   FinishPendingTasks();
 }

device/bluetooth/test/bluetooth_test_win.h

@@ -86,7 +86,6 @@ class BluetoothTestWin : public BluetoothTestBase,
   scoped_refptr<base::TestSimpleTaskRunner> ui_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> bluetooth_task_runner_;
 
-  win::BluetoothClassicWrapperFake* fake_bt_classic_wrapper_;
   win::BluetoothLowEnergyWrapperFake* fake_bt_le_wrapper_;
 
   // This is used for retaining access to a single deleted device.