[Telemetry SWX] Add bluetooth events

Create and make available mojo interface for chrome://.

Add implementation in chrome://.

Add implementation in chrome-untrusted://.

Add implementation for cros_healthd fake event emitters.

Add browser test for bluetooth event listener.

Bug: b:167523716
Change-Id: Iee440ec06446187943389d76158ece55d0c08dd8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2416280
Commit-Queue: Laurențiu Olteanu <lolteanu@google.com>
Reviewed-by: Oleh Lamzin <lamzin@google.com>
Reviewed-by: Mahmoud Gawad <mgawad@google.com>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Cr-Commit-Position: refs/heads/master@{#814214}

chromeos/components/telemetry_extension_ui/BUILD.gn

@@ -8,6 +8,8 @@ assert(!is_official_build,
 
 source_set("telemetry_extension_ui") {
   sources = [
+    "bluetooth_observer.cc",
+    "bluetooth_observer.h",
     "convert_ptr.h",
     "diagnostics_service.cc",
     "diagnostics_service.h",

chromeos/components/telemetry_extension_ui/bluetooth_observer.cc

+// Copyright 2020 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 "chromeos/components/telemetry_extension_ui/bluetooth_observer.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "chromeos/components/telemetry_extension_ui/mojom/system_events_service.mojom.h"
+#include "chromeos/services/cros_healthd/public/cpp/service_connection.h"
+
+namespace chromeos {
+
+BluetoothObserver::BluetoothObserver() : receiver_{this} {
+  Connect();
+}
+
+BluetoothObserver::~BluetoothObserver() = default;
+
+void BluetoothObserver::AddObserver(
+    mojo::PendingRemote<health::mojom::BluetoothObserver> observer) {
+  health::mojom::BluetoothObserverPtr ptr{std::move(observer)};
+  observers_.Add(ptr.PassInterface());
+}
+
+void BluetoothObserver::OnAdapterAdded() {
+  for (auto& observer : observers_) {
+    observer->OnAdapterAdded();
+  }
+}
+
+void BluetoothObserver::OnAdapterRemoved() {
+  for (auto& observer : observers_) {
+    observer->OnAdapterRemoved();
+  }
+}
+
+void BluetoothObserver::OnAdapterPropertyChanged() {
+  for (auto& observer : observers_) {
+    observer->OnAdapterPropertyChanged();
+  }
+}
+
+void BluetoothObserver::OnDeviceAdded() {
+  for (auto& observer : observers_) {
+    observer->OnDeviceAdded();
+  }
+}
+
+void BluetoothObserver::OnDeviceRemoved() {
+  for (auto& observer : observers_) {
+    observer->OnDeviceRemoved();
+  }
+}
+
+void BluetoothObserver::OnDevicePropertyChanged() {
+  for (auto& observer : observers_) {
+    observer->OnDevicePropertyChanged();
+  }
+}
+
+void BluetoothObserver::Connect() {
+  receiver_.reset();
+  cros_healthd::ServiceConnection::GetInstance()->AddBluetoothObserver(
+      receiver_.BindNewPipeAndPassRemote());
+
+  // We try to reconnect right after disconnect because Mojo will queue the
+  // request and connect to cros_healthd when it becomes available.
+  receiver_.set_disconnect_handler(
+      base::BindOnce(&BluetoothObserver::Connect, base::Unretained(this)));
+}
+
+void BluetoothObserver::FlushForTesting() {
+  receiver_.FlushForTesting();
+}
+
+}  // namespace chromeos

chromeos/components/telemetry_extension_ui/bluetooth_observer.h

+// Copyright 2020 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.
+
+#ifndef CHROMEOS_COMPONENTS_TELEMETRY_EXTENSION_UI_BLUETOOTH_OBSERVER_H_
+#define CHROMEOS_COMPONENTS_TELEMETRY_EXTENSION_UI_BLUETOOTH_OBSERVER_H_
+
+#if defined(OFFICIAL_BUILD)
+#error Bluetooth observer should only be included in unofficial builds.
+#endif
+
+#include "chromeos/components/telemetry_extension_ui/mojom/system_events_service.mojom-forward.h"
+#include "chromeos/services/cros_healthd/public/mojom/cros_healthd_events.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote_set.h"
+
+namespace chromeos {
+
+class BluetoothObserver
+    : public cros_healthd::mojom::CrosHealthdBluetoothObserver {
+ public:
+  BluetoothObserver();
+  BluetoothObserver(const BluetoothObserver&) = delete;
+  BluetoothObserver& operator=(const BluetoothObserver&) = delete;
+  ~BluetoothObserver() override;
+
+  void AddObserver(
+      mojo::PendingRemote<health::mojom::BluetoothObserver> observer);
+
+  void OnAdapterAdded() override;
+  void OnAdapterRemoved() override;
+  void OnAdapterPropertyChanged() override;
+  void OnDeviceAdded() override;
+  void OnDeviceRemoved() override;
+  void OnDevicePropertyChanged() override;
+
+  // Waits until disconnect handler will be triggered if fake cros_healthd was
+  // shutdown.
+  void FlushForTesting();
+
+ private:
+  void Connect();
+
+  mojo::Receiver<cros_healthd::mojom::CrosHealthdBluetoothObserver> receiver_;
+  mojo::RemoteSet<health::mojom::BluetoothObserver> observers_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_COMPONENTS_TELEMETRY_EXTENSION_UI_BLUETOOTH_OBSERVER_H_

chromeos/components/telemetry_extension_ui/mojom/system_events_service.mojom

@@ -16,6 +16,13 @@ module chromeos.health.mojom;
 
 // System Events interface exposed by the Telemetry SWX.
 interface SystemEventsService {
+  // Adds an observer to be notified on Bluetooth events. The caller can remove
+  // the observer created by this call by closing their end of the message pipe.
+  //
+  // The request:
+  // * |observer| - Bluetooth observer to be added to system events service.
+  AddBluetoothObserver(pending_remote<BluetoothObserver> observer);
+
   // Adds an observer to be notified on lid events. The caller can remove the
   // observer created by this call by closing their end of the message pipe.
   //
@@ -24,6 +31,22 @@ interface SystemEventsService {
   AddLidObserver(pending_remote<LidObserver> observer);
 };
 
+// Implemented by clients who desire Bluetooth notifications.
+interface BluetoothObserver {
+  // Fired when a Bluetooth adapter is added.
+  OnAdapterAdded();
+  // Fired when a Bluetooth adapter is removed.
+  OnAdapterRemoved();
+  // Fired when a property of a Bluetooth adapter is changed.
+  OnAdapterPropertyChanged();
+  // Fired when a Bluetooth device is added.
+  OnDeviceAdded();
+  // Fired when a Bluetooth device is removed.
+  OnDeviceRemoved();
+  // Fired when a property of a Bluetooth device is changed.
+  OnDevicePropertyChanged();
+};
+
 // Implemented by clients who desire lid notifications.
 interface LidObserver {
   // Fired when the device's lid is closed.

chromeos/components/telemetry_extension_ui/resources/trusted.js

@@ -880,10 +880,37 @@ class SystemEventsProxy {
     this.iframeReady = iframeReady;
 
     this.events = {
+      ON_BLUETOOTH_ADAPTER_ADDED: 'bluetooth-adapter-added',
+      ON_BLUETOOTH_ADAPTER_REMOVED: 'bluetooth-adapter-removed',
+      ON_BLUETOOTH_ADAPTER_PROPERTY_CHANGED:
+          'bluetooth-adapter-property-changed',
+      ON_BLUETOOTH_DEVICE_ADDED: 'bluetooth-device-added',
+      ON_BLUETOOTH_DEVICE_REMOVED: 'bluetooth-device-removed',
+      ON_BLUETOOTH_DEVICE_PROPERTY_CHANGED: 'bluetooth-device-property-changed',
       ON_LID_CLOSED: 'lid-closed',
       ON_LID_OPENED: 'lid-opened',
     };
 
+    this.bluetoothObserverCallbackRouter_ =
+        new chromeos.health.mojom.BluetoothObserverCallbackRouter();
+
+    this.bluetoothObserverCallbackRouter_.onAdapterAdded.addListener(
+        () => this.sendEvent(this.events.ON_BLUETOOTH_ADAPTER_ADDED));
+    this.bluetoothObserverCallbackRouter_.onAdapterRemoved.addListener(
+        () => this.sendEvent(this.events.ON_BLUETOOTH_ADAPTER_REMOVED));
+    this.bluetoothObserverCallbackRouter_.onAdapterPropertyChanged.addListener(
+        () =>
+            this.sendEvent(this.events.ON_BLUETOOTH_ADAPTER_PROPERTY_CHANGED));
+    this.bluetoothObserverCallbackRouter_.onDeviceAdded.addListener(
+        () => this.sendEvent(this.events.ON_BLUETOOTH_DEVICE_ADDED));
+    this.bluetoothObserverCallbackRouter_.onDeviceRemoved.addListener(
+        () => this.sendEvent(this.events.ON_BLUETOOTH_DEVICE_REMOVED));
+    this.bluetoothObserverCallbackRouter_.onDevicePropertyChanged.addListener(
+        () => this.sendEvent(this.events.ON_BLUETOOTH_DEVICE_PROPERTY_CHANGED));
+
+    getOrCreateSystemEventsService().addBluetoothObserver(
+        this.bluetoothObserverCallbackRouter_.$.bindNewPipeAndPassRemote());
+
     this.lidObserverCallbackRouter_ =
         new chromeos.health.mojom.LidObserverCallbackRouter();
 

chromeos/components/telemetry_extension_ui/system_events_service.cc

@@ -16,12 +16,18 @@ SystemEventsService::SystemEventsService(
 
 SystemEventsService::~SystemEventsService() = default;
 
+void SystemEventsService::AddBluetoothObserver(
+    mojo::PendingRemote<health::mojom::BluetoothObserver> observer) {
+  bluetooth_observer_.AddObserver(std::move(observer));
+}
+
 void SystemEventsService::AddLidObserver(
     mojo::PendingRemote<health::mojom::LidObserver> observer) {
   lid_observer_.AddObserver(std::move(observer));
 }
 
 void SystemEventsService::FlushForTesting() {
+  bluetooth_observer_.FlushForTesting();
   lid_observer_.FlushForTesting();
 }
 

chromeos/components/telemetry_extension_ui/system_events_service.h

@@ -9,6 +9,7 @@
 #error System events service should only be included in unofficial builds.
 #endif
 
+#include "chromeos/components/telemetry_extension_ui/bluetooth_observer.h"
 #include "chromeos/components/telemetry_extension_ui/lid_observer.h"
 #include "chromeos/components/telemetry_extension_ui/mojom/system_events_service.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
@@ -25,6 +26,9 @@ class SystemEventsService : public health::mojom::SystemEventsService {
   SystemEventsService& operator=(const SystemEventsService&) = delete;
   ~SystemEventsService() override;
 
+  void AddBluetoothObserver(
+      mojo::PendingRemote<health::mojom::BluetoothObserver> observer) override;
+
   void AddLidObserver(
       mojo::PendingRemote<health::mojom::LidObserver> observer) override;
 
@@ -33,6 +37,7 @@ class SystemEventsService : public health::mojom::SystemEventsService {
  private:
   mojo::Receiver<health::mojom::SystemEventsService> receiver_;
 
+  BluetoothObserver bluetooth_observer_;
   LidObserver lid_observer_;
 };
 

chromeos/components/telemetry_extension_ui/system_events_service_unittest.cc

@@ -26,6 +26,27 @@ namespace chromeos {
 
 namespace {
 
+class MockBluetoothObserver : public health::mojom::BluetoothObserver {
+ public:
+  MockBluetoothObserver() : receiver_{this} {}
+  MockBluetoothObserver(const MockBluetoothObserver&) = delete;
+  MockBluetoothObserver& operator=(const MockBluetoothObserver&) = delete;
+
+  mojo::PendingRemote<health::mojom::BluetoothObserver> pending_remote() {
+    return receiver_.BindNewPipeAndPassRemote();
+  }
+
+  MOCK_METHOD(void, OnAdapterAdded, (), (override));
+  MOCK_METHOD(void, OnAdapterRemoved, (), (override));
+  MOCK_METHOD(void, OnAdapterPropertyChanged, (), (override));
+  MOCK_METHOD(void, OnDeviceAdded, (), (override));
+  MOCK_METHOD(void, OnDeviceRemoved, (), (override));
+  MOCK_METHOD(void, OnDevicePropertyChanged, (), (override));
+
+ private:
+  mojo::Receiver<health::mojom::BluetoothObserver> receiver_;
+};
+
 class MockLidObserver : public health::mojom::LidObserver {
  public:
   MockLidObserver() : receiver_{this} {}
@@ -51,6 +72,8 @@ class SystemEventsServiceTest : public testing::Test {
     CrosHealthdClient::InitializeFake();
     system_events_service_ = std::make_unique<SystemEventsService>(
         remote_system_events_service_.BindNewPipeAndPassReceiver());
+    mock_bluetooth_observer_ =
+        std::make_unique<testing::StrictMock<MockBluetoothObserver>>();
     mock_lid_observer_ =
         std::make_unique<testing::StrictMock<MockLidObserver>>();
 
@@ -72,10 +95,19 @@ class SystemEventsServiceTest : public testing::Test {
     return system_events_service_.get();
   }
 
+  mojo::PendingRemote<health::mojom::BluetoothObserver> bluetooth_observer()
+      const {
+    return mock_bluetooth_observer_->pending_remote();
+  }
+
   mojo::PendingRemote<health::mojom::LidObserver> lid_observer() const {
     return mock_lid_observer_->pending_remote();
   }
 
+  MockBluetoothObserver* mock_bluetooth_observer() const {
+    return mock_bluetooth_observer_.get();
+  }
+
   MockLidObserver* mock_lid_observer() const {
     return mock_lid_observer_.get();
   }
@@ -85,9 +117,47 @@ class SystemEventsServiceTest : public testing::Test {
   mojo::Remote<health::mojom::SystemEventsService>
       remote_system_events_service_;
   std::unique_ptr<SystemEventsService> system_events_service_;
+  std::unique_ptr<testing::StrictMock<MockBluetoothObserver>>
+      mock_bluetooth_observer_;
   std::unique_ptr<testing::StrictMock<MockLidObserver>> mock_lid_observer_;
 };
 
+// Tests that in case of cros_healthd crash Bluetooth Observer will reconnect.
+TEST_F(SystemEventsServiceTest, BluetoothObserverReconnect) {
+  remote_system_events_service()->AddBluetoothObserver(bluetooth_observer());
+
+  base::RunLoop run_loop1;
+  EXPECT_CALL(*mock_bluetooth_observer(), OnAdapterAdded)
+      .WillOnce([&run_loop1]() { run_loop1.Quit(); });
+  cros_healthd::FakeCrosHealthdClient::Get()->EmitAdapterAddedEventForTesting();
+  run_loop1.Run();
+
+  // Shutdown cros_healthd to simulate crash.
+  CrosHealthdClient::Shutdown();
+
+  // Ensure ServiceConnection is disconnected from cros_healthd.
+  cros_healthd::ServiceConnection::GetInstance()->FlushForTesting();
+
+  // Restart cros_healthd.
+  CrosHealthdClient::InitializeFake();
+
+  // Ensure disconnect handler is called for bluetooth observer from System
+  // Events Service. After this call, we will have a Mojo pending connection
+  // task in Mojo message queue.
+  system_events_service()->FlushForTesting();
+
+  // Ensure that Mojo pending connection task from bluetooth observer gets
+  // processed and observer is bound. After this call, we are sure that
+  // bluetooth observer reconnected and we can safely emit events.
+  cros_healthd::ServiceConnection::GetInstance()->FlushForTesting();
+
+  base::RunLoop run_loop2;
+  EXPECT_CALL(*mock_bluetooth_observer(), OnAdapterAdded)
+      .WillOnce([&run_loop2]() { run_loop2.Quit(); });
+  cros_healthd::FakeCrosHealthdClient::Get()->EmitAdapterAddedEventForTesting();
+  run_loop2.Run();
+}
+
 // Tests that in case of cros_healthd crash Lid Observer will reconnect.
 TEST_F(SystemEventsServiceTest, LidObserverReconnect) {
   remote_system_events_service()->AddLidObserver(lid_observer());

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.cc

@@ -433,6 +433,54 @@ void TelemetryExtensionUiBrowserTest::ConfigureProbeServiceToReturnErrors() {
       ->SetProbeTelemetryInfoResponseForTesting(telemetry_info);
 }
 
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothAdapterAddedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitAdapterAddedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothAdapterRemovedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitAdapterRemovedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothAdapterPropertyChangedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitAdapterPropertyChangedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothDeviceAddedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitDeviceAddedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothDeviceRemovedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitDeviceRemovedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::
+    EmitBluetoothDevicePropertyChangedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitDevicePropertyChangedEventForTesting();
+  }));
+}
+
 void TelemetryExtensionUiBrowserTest::EmitLidClosedEventPeriodically() {
   RunCallbackPeriodically(base::BindRepeating([] {
     chromeos::cros_healthd::FakeCrosHealthdClient::Get()

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.h

@@ -29,6 +29,13 @@ class TelemetryExtensionUiBrowserTest : public SandboxedWebUiAppTestBase {
 
   void ConfigureProbeServiceToReturnErrors();
 
+  void EmitBluetoothAdapterAddedEventPeriodically();
+  void EmitBluetoothAdapterRemovedEventPeriodically();
+  void EmitBluetoothAdapterPropertyChangedEventPeriodically();
+  void EmitBluetoothDeviceAddedEventPeriodically();
+  void EmitBluetoothDeviceRemovedEventPeriodically();
+  void EmitBluetoothDevicePropertyChangedEventPeriodically();
+
   void EmitLidClosedEventPeriodically();
   void EmitLidOpenedEventPeriodically();
 

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.js

@@ -371,6 +371,54 @@ var TelemetryExtensionUIWithProbeServiceErrorsBrowserTest =
   }
 }
 
+var TelemetryExtensionUIWithAdapterAddedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothAdapterAddedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithAdapterRemovedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothAdapterRemovedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithAdapterPropertyChangedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothAdapterPropertyChangedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithDeviceAddedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothDeviceAddedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithDeviceRemovedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothDeviceRemovedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithDevicePropertyChangedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitBluetoothDevicePropertyChangedEventPeriodically();');
+  }
+}
+
 var TelemetryExtensionUIWithLidClosedEventBrowserTest =
     class extends TelemetryExtensionUIBrowserTest {
   /** @override */
@@ -438,6 +486,30 @@ const untrustedTests = [
     'UntrustedRequestTelemetryInfoWithErrors',
     'TelemetryExtensionUIWithProbeServiceErrorsBrowserTest'
   ],
+  [
+    'UntrustedBluetoothAdapterAddedEventListener',
+    'TelemetryExtensionUIWithAdapterAddedEventBrowserTest'
+  ],
+  [
+    'UntrustedBluetoothAdapterRemovedEventListener',
+    'TelemetryExtensionUIWithAdapterRemovedEventBrowserTest'
+  ],
+  [
+    'UntrustedBluetoothAdapterPropertyChangedEventListener',
+    'TelemetryExtensionUIWithAdapterPropertyChangedEventBrowserTest'
+  ],
+  [
+    'UntrustedBluetoothDeviceAddedEventListener',
+    'TelemetryExtensionUIWithDeviceAddedEventBrowserTest'
+  ],
+  [
+    'UntrustedBluetoothDeviceRemovedEventListener',
+    'TelemetryExtensionUIWithDeviceRemovedEventBrowserTest'
+  ],
+  [
+    'UntrustedBluetoothDevicePropertyChangedEventListener',
+    'TelemetryExtensionUIWithDevicePropertyChangedEventBrowserTest'
+  ],
   [
     'UntrustedLidClosedEventListener',
     'TelemetryExtensionUIWithLidClosedEventBrowserTest'

chromeos/components/telemetry_extension_ui/test/untrusted_browsertest.js

@@ -441,6 +441,52 @@ UNTRUSTED_TEST(
       assertDeepEquals(response, {id: 123456789, status: 'ready'});
     });
 
+// Tests that addEventListener receives system bluetooth adapter added event.
+UNTRUSTED_TEST('UntrustedBluetoothAdapterAddedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener(
+          'bluetooth-adapter-added', resolve));
+});
+
+// Tests that addEventListener receives system bluetooth adapter removed event.
+UNTRUSTED_TEST('UntrustedBluetoothAdapterRemovedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener(
+          'bluetooth-adapter-removed', resolve));
+});
+
+// Tests that addEventListener receives system bluetooth adapter property
+// changed event.
+UNTRUSTED_TEST(
+    'UntrustedBluetoothAdapterPropertyChangedEventListener', async () => {
+      await new Promise(
+          (resolve) => chromeos.telemetry.addEventListener(
+              'bluetooth-adapter-property-changed', resolve));
+    });
+
+// Tests that addEventListener receives system bluetooth device added event.
+UNTRUSTED_TEST('UntrustedBluetoothDeviceAddedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener(
+          'bluetooth-device-added', resolve));
+});
+
+// Tests that addEventListener receives system bluetooth device removed event.
+UNTRUSTED_TEST('UntrustedBluetoothDeviceRemovedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener(
+          'bluetooth-device-removed', resolve));
+});
+
+// Tests that addEventListener receives system bluetooth device property changed
+// event.
+UNTRUSTED_TEST(
+    'UntrustedBluetoothDevicePropertyChangedEventListener', async () => {
+      await new Promise(
+          (resolve) => chromeos.telemetry.addEventListener(
+              'bluetooth-device-property-changed', resolve));
+    });
+
 // Tests that addEventListener receives system lid closed event.
 UNTRUSTED_TEST('UntrustedLidClosedEventListener', async () => {
   await new Promise(

chromeos/dbus/cros_healthd/fake_cros_healthd_client.cc

@@ -85,6 +85,41 @@ void FakeCrosHealthdClient::EmitAdapterAddedEventForTesting() {
   fake_service_.EmitAdapterAddedEventForTesting();
 }
 
+void FakeCrosHealthdClient::EmitAdapterRemovedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitAdapterRemovedEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitAdapterPropertyChangedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitAdapterPropertyChangedEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitDeviceAddedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitDeviceAddedEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitDeviceRemovedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitDeviceRemovedEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitDevicePropertyChangedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitDevicePropertyChangedEventForTesting();
+}
+
 void FakeCrosHealthdClient::EmitLidClosedEventForTesting() {
   // Flush the receiver, so any pending observers are registered before the
   // event is emitted.

chromeos/dbus/cros_healthd/fake_cros_healthd_client.h

@@ -69,6 +69,26 @@ class COMPONENT_EXPORT(CROS_HEALTHD) FakeCrosHealthdClient
   // observers.
   void EmitAdapterAddedEventForTesting();
 
+  // Calls the Bluetooth event OnAdapterRemoved on all registered Bluetooth
+  // observers.
+  void EmitAdapterRemovedEventForTesting();
+
+  // Calls the Bluetooth event OnAdapterPropertyChanged on all registered
+  // Bluetooth observers.
+  void EmitAdapterPropertyChangedEventForTesting();
+
+  // Calls the Bluetooth event OnDeviceAdded on all registered Bluetooth
+  // observers.
+  void EmitDeviceAddedEventForTesting();
+
+  // Calls the Bluetooth event OnDeviceRemoved on all registered Bluetooth
+  // observers.
+  void EmitDeviceRemovedEventForTesting();
+
+  // Calls the Bluetooth event OnDevicePropertyChanged on all registered
+  // Bluetooth observers.
+  void EmitDevicePropertyChangedEventForTesting();
+
   // Calls the lid event OnLidClosed on all registered lid observers.
   void EmitLidClosedEventForTesting();
 

chromeos/dbus/cros_healthd/fake_cros_healthd_service.cc

@@ -288,6 +288,31 @@ void FakeCrosHealthdService::EmitAdapterAddedEventForTesting() {
     observer->OnAdapterAdded();
 }
 
+void FakeCrosHealthdService::EmitAdapterRemovedEventForTesting() {
+  for (auto& observer : bluetooth_observers_)
+    observer->OnAdapterRemoved();
+}
+
+void FakeCrosHealthdService::EmitAdapterPropertyChangedEventForTesting() {
+  for (auto& observer : bluetooth_observers_)
+    observer->OnAdapterPropertyChanged();
+}
+
+void FakeCrosHealthdService::EmitDeviceAddedEventForTesting() {
+  for (auto& observer : bluetooth_observers_)
+    observer->OnDeviceAdded();
+}
+
+void FakeCrosHealthdService::EmitDeviceRemovedEventForTesting() {
+  for (auto& observer : bluetooth_observers_)
+    observer->OnDeviceRemoved();
+}
+
+void FakeCrosHealthdService::EmitDevicePropertyChangedEventForTesting() {
+  for (auto& observer : bluetooth_observers_)
+    observer->OnDevicePropertyChanged();
+}
+
 void FakeCrosHealthdService::EmitLidClosedEventForTesting() {
   for (auto& observer : lid_observers_)
     observer->OnLidClosed();

chromeos/dbus/cros_healthd/fake_cros_healthd_service.h

@@ -149,6 +149,26 @@ class FakeCrosHealthdService final
   // observers.
   void EmitAdapterAddedEventForTesting();
 
+  // Calls the Bluetooth event OnAdapterRemoved on all registered Bluetooth
+  // observers.
+  void EmitAdapterRemovedEventForTesting();
+
+  // Calls the Bluetooth event OnAdapterPropertyChanged on all registered
+  // Bluetooth observers.
+  void EmitAdapterPropertyChangedEventForTesting();
+
+  // Calls the Bluetooth event OnDeviceAdded on all registered Bluetooth
+  // observers.
+  void EmitDeviceAddedEventForTesting();
+
+  // Calls the Bluetooth event OnDeviceRemoved on all registered Bluetooth
+  // observers.
+  void EmitDeviceRemovedEventForTesting();
+
+  // Calls the Bluetooth event OnDevicePropertyChanged on all registered
+  // Bluetooth observers.
+  void EmitDevicePropertyChangedEventForTesting();
+
   // Calls the lid event OnLidClosed for all registered lid observers.
   void EmitLidClosedEventForTesting();