services/device/serial/bluetooth_serial_device_enumerator_unittests.cc - chromium/src.git - Git at Google

 // Copyright 2021 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "services/device/serial/bluetooth_serial_device_enumerator.h"

 #include <memory>
 #include <optional>

 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_future.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "services/device/public/cpp/bluetooth/bluetooth_utils.h"
 #include "services/device/public/cpp/device_features.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace device {

 namespace {

 using ::base::test::InvokeFuture;
 using ::base::test::TestFuture;
 using ::testing::NiceMock;
 using ::testing::Return;

 constexpr char kTestDeviceAddress[] = "11:12:13:14:15:16";
 constexpr char kTestDeviceName[] = "Device w/SPP";

 std::unique_ptr<device::MockBluetoothDevice> CreateDevice(
     device::MockBluetoothAdapter* adapter,
     const char* device_name,
     const std::string& device_address) {
   return std::make_unique<NiceMock<device::MockBluetoothDevice>>(
       adapter, /*bluetooth_class=*/0u, device_name, device_address,
       /*paired=*/true, /*connected=*/true);
 }

 class MockSerialPortEnumeratorObserver
     : public SerialDeviceEnumerator::Observer {
  public:
   MOCK_METHOD1(OnPortAdded, void(const mojom::SerialPortInfo&));
   MOCK_METHOD1(OnPortRemoved, void(const mojom::SerialPortInfo&));
   MOCK_METHOD1(OnPortConnectedStateChanged, void(const mojom::SerialPortInfo&));
 };

 class BluetoothSerialDeviceEnumeratorTest : public testing::Test {
  public:
   BluetoothSerialDeviceEnumeratorTest() = default;

   scoped_refptr<base::SingleThreadTaskRunner> adapter_runner() {
     return task_environment_.GetMainThreadTaskRunner();
   }

  private:
   base::test::TaskEnvironment task_environment_;
 };

 }  // namespace

 TEST_F(BluetoothSerialDeviceEnumeratorTest, ConstructDestruct) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
   base::RunLoop run_loop;
   mock_adapter->Initialize(run_loop.QuitClosure());
   run_loop.Run();
   EXPECT_TRUE(mock_adapter->IsInitialized());

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

   BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
   // Prevent memory leak warning.
   enumerator.SynchronouslyResetHelperForTesting();
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest, ConstructWaitForAdapter) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

   {
     base::RunLoop run_loop;
     mock_adapter->Initialize(run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(mock_adapter->IsInitialized());
   }

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

   BluetoothSerialDeviceEnumerator enumerator(adapter_runner());

   // Wait for the enumerator to complete its initial enumeration.
   TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
   enumerator.GetDevicesAfterInitialEnumeration(
       get_devices_future.GetCallback());
   ASSERT_TRUE(get_devices_future.Wait());

   // Prevent memory leak warning.
   enumerator.SynchronouslyResetHelperForTesting();
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest, GetDevices) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

   base::RunLoop run_loop;
   mock_adapter->Initialize(run_loop.QuitClosure());
   run_loop.Run();
   EXPECT_TRUE(mock_adapter->IsInitialized());

   auto mock_device =
       CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
   mock_device->AddUUID(GetSerialPortProfileUUID());
   mock_adapter->AddMockDevice(std::move(mock_device));
   EXPECT_CALL(*mock_adapter, GetDevices())
       .WillOnce(Return(mock_adapter->GetConstMockDevices()));

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

   BluetoothSerialDeviceEnumerator enumerator(adapter_runner());

   // Before the initial enumeration GetDevices returns no ports.
   EXPECT_TRUE(enumerator.GetDevices().empty());

   // Check that the port is found during initial enumeration.
   TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
   enumerator.GetDevicesAfterInitialEnumeration(
       get_devices_future.GetCallback());
   EXPECT_EQ(1u, get_devices_future.Get().size());

   // After the initial enumeration GetDevices returns the port.
   EXPECT_EQ(1u, enumerator.GetDevices().size());

   // Prevent memory leak warning.
   enumerator.SynchronouslyResetHelperForTesting();
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest, CreateWithDevice) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

   {
     base::RunLoop run_loop;
     mock_adapter->Initialize(run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(mock_adapter->IsInitialized());
   }

   auto mock_device =
       CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
   mock_device->AddUUID(GetSerialPortProfileUUID());
   mock_adapter->AddMockDevice(std::move(mock_device));
   EXPECT_CALL(*mock_adapter, GetDevices())
       .WillOnce(Return(mock_adapter->GetConstMockDevices()));

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

   BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
   MockSerialPortEnumeratorObserver observer;
   enumerator.AddObserver(&observer);
   TestFuture<const device::mojom::SerialPortInfo&> port_future;
   EXPECT_CALL(observer, OnPortAdded).WillOnce(InvokeFuture(port_future));
   EXPECT_FALSE(port_future.Get().token.is_empty());
   EXPECT_EQ(base::FilePath::FromASCII(kTestDeviceAddress),
             port_future.Get().path);
   EXPECT_EQ(kTestDeviceName, port_future.Get().display_name);
   EXPECT_EQ(std::nullopt, port_future.Get().serial_number);
   EXPECT_EQ(mojom::SerialPortType::BLUETOOTH_CLASSIC_RFCOMM,
             port_future.Get().type);
   EXPECT_FALSE(port_future.Get().has_vendor_id);
   EXPECT_EQ(0x0, port_future.Get().vendor_id);
   EXPECT_FALSE(port_future.Get().has_product_id);
   EXPECT_EQ(0x0, port_future.Get().product_id);

   TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
   enumerator.GetDevicesAfterInitialEnumeration(
       get_devices_future.GetCallback());
   ASSERT_EQ(1u, get_devices_future.Get().size());

   auto address = enumerator.GetAddressFromToken(port_future.Get().token);
   ASSERT_TRUE(address);
   EXPECT_EQ(*address, kTestDeviceAddress);
   EXPECT_EQ(GetSerialPortProfileUUID(),
             enumerator.GetServiceClassIdFromToken(port_future.Get().token));

   const base::UnguessableToken unused_token;
   EXPECT_FALSE(enumerator.GetAddressFromToken(unused_token));
   EXPECT_FALSE(enumerator.GetServiceClassIdFromToken(unused_token).IsValid());

   // Second add - which will be skipped.
   const BluetoothDevice::UUIDSet service_class_ids = {
       GetSerialPortProfileUUID()};
   const std::u16string device_name(
       base::UTF8ToUTF16(std::string(kTestDeviceName)));
   enumerator.DeviceAddedOrChanged(kTestDeviceAddress, device_name,
                                   service_class_ids, /*is_connected=*/true);
   ASSERT_EQ(1u, enumerator.GetDevices().size());

   // Remove device.
   TestFuture<const mojom::SerialPortInfo&> disconnect_future;
   EXPECT_CALL(observer, OnPortConnectedStateChanged).Times(0);
   EXPECT_CALL(observer, OnPortRemoved)
       .WillOnce(InvokeFuture(disconnect_future));
   enumerator.DeviceRemoved(kTestDeviceAddress);
   EXPECT_EQ(disconnect_future.Get().token, port_future.Get().token);
   EXPECT_FALSE(disconnect_future.Get().connected);

   // Remove again - now nonexistent.
   enumerator.DeviceRemoved(kTestDeviceAddress);

   // Prevent memory leak warning.
   enumerator.SynchronouslyResetHelperForTesting();
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest, PortConnectedState) {
   base::test::ScopedFeatureList scoped_feature_list(
       features::kSerialPortConnected);

   // Set a mock adapter and wait until it is initialized.
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
   base::RunLoop adapter_initialized_loop;
   mock_adapter->Initialize(adapter_initialized_loop.QuitClosure());
   adapter_initialized_loop.Run();
   EXPECT_TRUE(mock_adapter->IsInitialized());

   // Create the enumerator and wait until it has completed its initial
   // enumeration.
   EXPECT_CALL(*mock_adapter, GetDevices())
       .WillOnce(Return(mock_adapter->GetConstMockDevices()));
   BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
   TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
   enumerator.GetDevicesAfterInitialEnumeration(
       get_devices_future.GetCallback());
   ASSERT_TRUE(get_devices_future.Wait());

   MockSerialPortEnumeratorObserver observer;
   enumerator.AddObserver(&observer);

   // Create a Bluetooth device with a serial port.
   auto mock_device =
       CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
   mock_device->AddUUID(GetSerialPortProfileUUID());

   // Add the device. The observer is notified that a new port was added.
   TestFuture<const mojom::SerialPortInfo&> port_future;
   EXPECT_CALL(observer, OnPortAdded).WillOnce(InvokeFuture(port_future));
   EXPECT_CALL(observer, OnPortConnectedStateChanged).Times(0);
   enumerator.DeviceAddedForTesting(mock_adapter.get(), mock_device.get());
   EXPECT_TRUE(port_future.Get().connected);

   // Disconnect the Bluetooth device and wait for the observer to be notified.
   TestFuture<const mojom::SerialPortInfo&> disconnect_future;
   EXPECT_CALL(observer, OnPortConnectedStateChanged)
       .WillOnce(InvokeFuture(disconnect_future));
   mock_device->SetConnected(false);
   enumerator.DeviceChangedForTesting(mock_adapter.get(), mock_device.get());
   EXPECT_EQ(disconnect_future.Get().token, port_future.Get().token);
   EXPECT_FALSE(disconnect_future.Get().connected);

   // Reconnect the Bluetooth device and wait for the observer to be notified.
   TestFuture<const mojom::SerialPortInfo&> reconnect_future;
   EXPECT_CALL(observer, OnPortConnectedStateChanged)
       .WillOnce(InvokeFuture(reconnect_future));
   mock_device->SetConnected(true);
   enumerator.DeviceChangedForTesting(mock_adapter.get(), mock_device.get());
   EXPECT_EQ(reconnect_future.Get().token, port_future.Get().token);
   EXPECT_TRUE(reconnect_future.Get().connected);

   // Prevent memory leak warning.
   enumerator.SynchronouslyResetHelperForTesting();
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest,
        RemoveObserverIsCalledWhenAdapterHelperDestruct) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
   {
     base::RunLoop run_loop;
     mock_adapter->Initialize(run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(mock_adapter->IsInitialized());
   }

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
   std::unique_ptr<BluetoothSerialDeviceEnumerator> enumerator;
   {
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_adapter, AddObserver)
         .WillOnce([&run_loop](BluetoothAdapter::Observer* observer) {
           run_loop.Quit();
         });
     enumerator =
         std::make_unique<BluetoothSerialDeviceEnumerator>(adapter_runner());
     run_loop.Run();
   }
   {
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_adapter, RemoveObserver)
         .WillOnce([&run_loop](BluetoothAdapter::Observer* observer) {
           run_loop.Quit();
         });
     enumerator->SynchronouslyResetHelperForTesting();
     run_loop.Run();
   }
 }

 TEST_F(BluetoothSerialDeviceEnumeratorTest,
        PendingCallbacksInvokedOnDestruction) {
   auto mock_adapter =
       base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
   {
     base::RunLoop run_loop;
     mock_adapter->Initialize(run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(mock_adapter->IsInitialized());
   }

   device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
   auto enumerator =
       std::make_unique<BluetoothSerialDeviceEnumerator>(adapter_runner());

   TestFuture<std::vector<mojom::SerialPortInfoPtr>> get_devices_future;
   enumerator->GetDevicesAfterInitialEnumeration(
       get_devices_future.GetCallback());

   // Destroy the enumerator and make sure the callback is called.
   enumerator->SynchronouslyResetHelperForTesting();
   enumerator.reset();
   EXPECT_TRUE(get_devices_future.Get().empty());
 }

 }  // namespace device
	// Copyright 2021 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "services/device/serial/bluetooth_serial_device_enumerator.h"

	#include <memory>
	#include <optional>

	#include "base/command_line.h"
	#include "base/run_loop.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/task/single_thread_task_runner.h"
	#include "base/test/scoped_feature_list.h"
	#include "base/test/task_environment.h"
	#include "base/test/test_future.h"
	#include "device/bluetooth/bluetooth_adapter_factory.h"
	#include "device/bluetooth/test/mock_bluetooth_adapter.h"
	#include "services/device/public/cpp/bluetooth/bluetooth_utils.h"
	#include "services/device/public/cpp/device_features.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace device {

	namespace {

	using ::base::test::InvokeFuture;
	using ::base::test::TestFuture;
	using ::testing::NiceMock;
	using ::testing::Return;

	constexpr char kTestDeviceAddress[] = "11:12:13:14:15:16";
	constexpr char kTestDeviceName[] = "Device w/SPP";

	std::unique_ptr<device::MockBluetoothDevice> CreateDevice(
	device::MockBluetoothAdapter* adapter,
	const char* device_name,
	const std::string& device_address) {
	return std::make_unique<NiceMock<device::MockBluetoothDevice>>(
	adapter, /bluetooth_class=/0u, device_name, device_address,
	/paired=/true, /connected=/true);
	}

	class MockSerialPortEnumeratorObserver
	: public SerialDeviceEnumerator::Observer {
	public:
	MOCK_METHOD1(OnPortAdded, void(const mojom::SerialPortInfo&));
	MOCK_METHOD1(OnPortRemoved, void(const mojom::SerialPortInfo&));
	MOCK_METHOD1(OnPortConnectedStateChanged, void(const mojom::SerialPortInfo&));
	};

	class BluetoothSerialDeviceEnumeratorTest : public testing::Test {
	public:
	BluetoothSerialDeviceEnumeratorTest() = default;

	scoped_refptr<base::SingleThreadTaskRunner> adapter_runner() {
	return task_environment_.GetMainThreadTaskRunner();
	}

	private:
	base::test::TaskEnvironment task_environment_;
	};

	} // namespace

	TEST_F(BluetoothSerialDeviceEnumeratorTest, ConstructDestruct) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

	BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
	// Prevent memory leak warning.
	enumerator.SynchronouslyResetHelperForTesting();
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest, ConstructWaitForAdapter) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

	{
	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());
	}

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

	BluetoothSerialDeviceEnumerator enumerator(adapter_runner());

	// Wait for the enumerator to complete its initial enumeration.
	TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
	enumerator.GetDevicesAfterInitialEnumeration(
	get_devices_future.GetCallback());
	ASSERT_TRUE(get_devices_future.Wait());

	// Prevent memory leak warning.
	enumerator.SynchronouslyResetHelperForTesting();
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest, GetDevices) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());

	auto mock_device =
	CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
	mock_device->AddUUID(GetSerialPortProfileUUID());
	mock_adapter->AddMockDevice(std::move(mock_device));
	EXPECT_CALL(*mock_adapter, GetDevices())
	.WillOnce(Return(mock_adapter->GetConstMockDevices()));

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

	BluetoothSerialDeviceEnumerator enumerator(adapter_runner());

	// Before the initial enumeration GetDevices returns no ports.
	EXPECT_TRUE(enumerator.GetDevices().empty());

	// Check that the port is found during initial enumeration.
	TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
	enumerator.GetDevicesAfterInitialEnumeration(
	get_devices_future.GetCallback());
	EXPECT_EQ(1u, get_devices_future.Get().size());

	// After the initial enumeration GetDevices returns the port.
	EXPECT_EQ(1u, enumerator.GetDevices().size());

	// Prevent memory leak warning.
	enumerator.SynchronouslyResetHelperForTesting();
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest, CreateWithDevice) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();

	{
	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());
	}

	auto mock_device =
	CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
	mock_device->AddUUID(GetSerialPortProfileUUID());
	mock_adapter->AddMockDevice(std::move(mock_device));
	EXPECT_CALL(*mock_adapter, GetDevices())
	.WillOnce(Return(mock_adapter->GetConstMockDevices()));

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);

	BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
	MockSerialPortEnumeratorObserver observer;
	enumerator.AddObserver(&observer);
	TestFuture<const device::mojom::SerialPortInfo&> port_future;
	EXPECT_CALL(observer, OnPortAdded).WillOnce(InvokeFuture(port_future));
	EXPECT_FALSE(port_future.Get().token.is_empty());
	EXPECT_EQ(base::FilePath::FromASCII(kTestDeviceAddress),
	port_future.Get().path);
	EXPECT_EQ(kTestDeviceName, port_future.Get().display_name);
	EXPECT_EQ(std::nullopt, port_future.Get().serial_number);
	EXPECT_EQ(mojom::SerialPortType::BLUETOOTH_CLASSIC_RFCOMM,
	port_future.Get().type);
	EXPECT_FALSE(port_future.Get().has_vendor_id);
	EXPECT_EQ(0x0, port_future.Get().vendor_id);
	EXPECT_FALSE(port_future.Get().has_product_id);
	EXPECT_EQ(0x0, port_future.Get().product_id);

	TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
	enumerator.GetDevicesAfterInitialEnumeration(
	get_devices_future.GetCallback());
	ASSERT_EQ(1u, get_devices_future.Get().size());

	auto address = enumerator.GetAddressFromToken(port_future.Get().token);
	ASSERT_TRUE(address);
	EXPECT_EQ(*address, kTestDeviceAddress);
	EXPECT_EQ(GetSerialPortProfileUUID(),
	enumerator.GetServiceClassIdFromToken(port_future.Get().token));

	const base::UnguessableToken unused_token;
	EXPECT_FALSE(enumerator.GetAddressFromToken(unused_token));
	EXPECT_FALSE(enumerator.GetServiceClassIdFromToken(unused_token).IsValid());

	// Second add - which will be skipped.
	const BluetoothDevice::UUIDSet service_class_ids = {
	GetSerialPortProfileUUID()};
	const std::u16string device_name(
	base::UTF8ToUTF16(std::string(kTestDeviceName)));
	enumerator.DeviceAddedOrChanged(kTestDeviceAddress, device_name,
	service_class_ids, /is_connected=/true);
	ASSERT_EQ(1u, enumerator.GetDevices().size());

	// Remove device.
	TestFuture<const mojom::SerialPortInfo&> disconnect_future;
	EXPECT_CALL(observer, OnPortConnectedStateChanged).Times(0);
	EXPECT_CALL(observer, OnPortRemoved)
	.WillOnce(InvokeFuture(disconnect_future));
	enumerator.DeviceRemoved(kTestDeviceAddress);
	EXPECT_EQ(disconnect_future.Get().token, port_future.Get().token);
	EXPECT_FALSE(disconnect_future.Get().connected);

	// Remove again - now nonexistent.
	enumerator.DeviceRemoved(kTestDeviceAddress);

	// Prevent memory leak warning.
	enumerator.SynchronouslyResetHelperForTesting();
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest, PortConnectedState) {
	base::test::ScopedFeatureList scoped_feature_list(
	features::kSerialPortConnected);

	// Set a mock adapter and wait until it is initialized.
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
	base::RunLoop adapter_initialized_loop;
	mock_adapter->Initialize(adapter_initialized_loop.QuitClosure());
	adapter_initialized_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());

	// Create the enumerator and wait until it has completed its initial
	// enumeration.
	EXPECT_CALL(*mock_adapter, GetDevices())
	.WillOnce(Return(mock_adapter->GetConstMockDevices()));
	BluetoothSerialDeviceEnumerator enumerator(adapter_runner());
	TestFuture<std::vector<device::mojom::SerialPortInfoPtr>> get_devices_future;
	enumerator.GetDevicesAfterInitialEnumeration(
	get_devices_future.GetCallback());
	ASSERT_TRUE(get_devices_future.Wait());

	MockSerialPortEnumeratorObserver observer;
	enumerator.AddObserver(&observer);

	// Create a Bluetooth device with a serial port.
	auto mock_device =
	CreateDevice(mock_adapter.get(), kTestDeviceName, kTestDeviceAddress);
	mock_device->AddUUID(GetSerialPortProfileUUID());

	// Add the device. The observer is notified that a new port was added.
	TestFuture<const mojom::SerialPortInfo&> port_future;
	EXPECT_CALL(observer, OnPortAdded).WillOnce(InvokeFuture(port_future));
	EXPECT_CALL(observer, OnPortConnectedStateChanged).Times(0);
	enumerator.DeviceAddedForTesting(mock_adapter.get(), mock_device.get());
	EXPECT_TRUE(port_future.Get().connected);

	// Disconnect the Bluetooth device and wait for the observer to be notified.
	TestFuture<const mojom::SerialPortInfo&> disconnect_future;
	EXPECT_CALL(observer, OnPortConnectedStateChanged)
	.WillOnce(InvokeFuture(disconnect_future));
	mock_device->SetConnected(false);
	enumerator.DeviceChangedForTesting(mock_adapter.get(), mock_device.get());
	EXPECT_EQ(disconnect_future.Get().token, port_future.Get().token);
	EXPECT_FALSE(disconnect_future.Get().connected);

	// Reconnect the Bluetooth device and wait for the observer to be notified.
	TestFuture<const mojom::SerialPortInfo&> reconnect_future;
	EXPECT_CALL(observer, OnPortConnectedStateChanged)
	.WillOnce(InvokeFuture(reconnect_future));
	mock_device->SetConnected(true);
	enumerator.DeviceChangedForTesting(mock_adapter.get(), mock_device.get());
	EXPECT_EQ(reconnect_future.Get().token, port_future.Get().token);
	EXPECT_TRUE(reconnect_future.Get().connected);

	// Prevent memory leak warning.
	enumerator.SynchronouslyResetHelperForTesting();
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest,
	RemoveObserverIsCalledWhenAdapterHelperDestruct) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
	{
	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());
	}

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
	std::unique_ptr<BluetoothSerialDeviceEnumerator> enumerator;
	{
	base::RunLoop run_loop;
	EXPECT_CALL(*mock_adapter, AddObserver)
	.WillOnce([&run_loop](BluetoothAdapter::Observer* observer) {
	run_loop.Quit();
	});
	enumerator =
	std::make_unique<BluetoothSerialDeviceEnumerator>(adapter_runner());
	run_loop.Run();
	}
	{
	base::RunLoop run_loop;
	EXPECT_CALL(*mock_adapter, RemoveObserver)
	.WillOnce([&run_loop](BluetoothAdapter::Observer* observer) {
	run_loop.Quit();
	});
	enumerator->SynchronouslyResetHelperForTesting();
	run_loop.Run();
	}
	}

	TEST_F(BluetoothSerialDeviceEnumeratorTest,
	PendingCallbacksInvokedOnDestruction) {
	auto mock_adapter =
	base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
	{
	base::RunLoop run_loop;
	mock_adapter->Initialize(run_loop.QuitClosure());
	run_loop.Run();
	EXPECT_TRUE(mock_adapter->IsInitialized());
	}

	device::BluetoothAdapterFactory::Get()->SetAdapterForTesting(mock_adapter);
	auto enumerator =
	std::make_unique<BluetoothSerialDeviceEnumerator>(adapter_runner());

	TestFuture<std::vector<mojom::SerialPortInfoPtr>> get_devices_future;
	enumerator->GetDevicesAfterInitialEnumeration(
	get_devices_future.GetCallback());

	// Destroy the enumerator and make sure the callback is called.
	enumerator->SynchronouslyResetHelperForTesting();
	enumerator.reset();
	EXPECT_TRUE(get_devices_future.Get().empty());
	}

	} // namespace device