[Telemetry SWX] Add power 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 power event listener.

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

chromeos/components/telemetry_extension_ui/BUILD.gn

@@ -17,6 +17,8 @@ source_set("telemetry_extension_ui") {
     "diagnostics_service_converters.h",
     "lid_observer.cc",
     "lid_observer.h",
+    "power_observer.cc",
+    "power_observer.h",
     "probe_service.cc",
     "probe_service.h",
     "probe_service_converters.cc",

chromeos/components/telemetry_extension_ui/mojom/system_events_service.mojom

@@ -9,8 +9,8 @@
 // This Mojo interface will go through security review before shipping.
 //
 // This is a subset of the cros_healthd event service interface which is
-// src/chrome/services/cros_healthd/public/mojom/cros_healthd.mojom and
-// src/chrome/services/cros_healthd/public/mojom/cros_healthd_events.mojom.
+// src/chromeos/services/cros_healthd/public/mojom/cros_healthd.mojom and
+// src/chromeos/services/cros_healthd/public/mojom/cros_healthd_events.mojom.
 
 module chromeos.health.mojom;
 
@@ -29,6 +29,13 @@ interface SystemEventsService {
   // The request:
   // * |observer| - lid observer to be added to system events service.
   AddLidObserver(pending_remote<LidObserver> observer);
+
+  // Adds an observer to be notified on power events. The caller can remove the
+  // observer created by this call by closing their end of the message pipe.
+  //
+  // The request:
+  // * |observer| - power observer to be added to system events service.
+  AddPowerObserver(pending_remote<PowerObserver> observer);
 };
 
 // Implemented by clients who desire Bluetooth notifications.
@@ -54,3 +61,16 @@ interface LidObserver {
   // Fired when the device's lid is opened.
   OnLidOpened();
 };
+
+// Implemented by clients who desire power notifications.
+interface PowerObserver {
+  // Fired when the power cable is plugged in.
+  OnAcInserted();
+  // Fired when the power cable is unplugged.
+  OnAcRemoved();
+  // Fired when the system is going to be suspended.
+  OnOsSuspend();
+  // Fired when the system was resumed after being suspended or when the suspend
+  // process was cancelled.
+  OnOsResume();
+};

chromeos/components/telemetry_extension_ui/power_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/power_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 {
+
+PowerObserver::PowerObserver() : receiver_{this} {
+  Connect();
+}
+
+PowerObserver::~PowerObserver() = default;
+
+void PowerObserver::AddObserver(
+    mojo::PendingRemote<health::mojom::PowerObserver> observer) {
+  health::mojom::PowerObserverPtr ptr{std::move(observer)};
+  observers_.Add(ptr.PassInterface());
+}
+
+void PowerObserver::OnAcInserted() {
+  for (auto& observer : observers_) {
+    observer->OnAcInserted();
+  }
+}
+
+void PowerObserver::OnAcRemoved() {
+  for (auto& observer : observers_) {
+    observer->OnAcRemoved();
+  }
+}
+
+void PowerObserver::OnOsSuspend() {
+  for (auto& observer : observers_) {
+    observer->OnOsSuspend();
+  }
+}
+
+void PowerObserver::OnOsResume() {
+  for (auto& observer : observers_) {
+    observer->OnOsResume();
+  }
+}
+
+void PowerObserver::Connect() {
+  receiver_.reset();
+  cros_healthd::ServiceConnection::GetInstance()->AddPowerObserver(
+      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(&PowerObserver::Connect, base::Unretained(this)));
+}
+
+void PowerObserver::FlushForTesting() {
+  receiver_.FlushForTesting();
+}
+
+}  // namespace chromeos

chromeos/components/telemetry_extension_ui/power_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_POWER_OBSERVER_H_
+#define CHROMEOS_COMPONENTS_TELEMETRY_EXTENSION_UI_POWER_OBSERVER_H_
+
+#if defined(OFFICIAL_BUILD)
+#error Power 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 PowerObserver : public cros_healthd::mojom::CrosHealthdPowerObserver {
+ public:
+  PowerObserver();
+  PowerObserver(const PowerObserver&) = delete;
+  PowerObserver& operator=(const PowerObserver&) = delete;
+  ~PowerObserver() override;
+
+  void AddObserver(mojo::PendingRemote<health::mojom::PowerObserver> observer);
+
+  void OnAcInserted() override;
+  void OnAcRemoved() override;
+  void OnOsSuspend() override;
+  void OnOsResume() override;
+
+  // Waits until disconnect handler will be triggered if fake cros_healthd was
+  // shutdown.
+  void FlushForTesting();
+
+ private:
+  void Connect();
+
+  mojo::Receiver<cros_healthd::mojom::CrosHealthdPowerObserver> receiver_;
+  mojo::RemoteSet<health::mojom::PowerObserver> observers_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_COMPONENTS_TELEMETRY_EXTENSION_UI_POWER_OBSERVER_H_

chromeos/components/telemetry_extension_ui/resources/trusted.js

@@ -889,6 +889,10 @@ class SystemEventsProxy {
       ON_BLUETOOTH_DEVICE_PROPERTY_CHANGED: 'bluetooth-device-property-changed',
       ON_LID_CLOSED: 'lid-closed',
       ON_LID_OPENED: 'lid-opened',
+      ON_AC_INSERTED: 'ac-inserted',
+      ON_AC_REMOVED: 'ac-removed',
+      ON_OS_SUSPEND: 'os-suspend',
+      ON_OS_RESUME: 'os-resume',
     };
 
     this.bluetoothObserverCallbackRouter_ =
@@ -921,6 +925,21 @@ class SystemEventsProxy {
 
     getOrCreateSystemEventsService().addLidObserver(
         this.lidObserverCallbackRouter_.$.bindNewPipeAndPassRemote());
+
+    this.powerObserverCallbackRouter_ =
+        new chromeos.health.mojom.PowerObserverCallbackRouter();
+
+    this.powerObserverCallbackRouter_.onAcInserted.addListener(
+        () => this.sendEvent(this.events.ON_AC_INSERTED));
+    this.powerObserverCallbackRouter_.onAcRemoved.addListener(
+        () => this.sendEvent(this.events.ON_AC_REMOVED));
+    this.powerObserverCallbackRouter_.onOsSuspend.addListener(
+        () => this.sendEvent(this.events.ON_OS_SUSPEND));
+    this.powerObserverCallbackRouter_.onOsResume.addListener(
+        () => this.sendEvent(this.events.ON_OS_RESUME));
+
+    getOrCreateSystemEventsService().addPowerObserver(
+        this.powerObserverCallbackRouter_.$.bindNewPipeAndPassRemote());
   }
 
   /**

chromeos/components/telemetry_extension_ui/system_events_service.cc

@@ -26,9 +26,15 @@ void SystemEventsService::AddLidObserver(
   lid_observer_.AddObserver(std::move(observer));
 }
 
+void SystemEventsService::AddPowerObserver(
+    mojo::PendingRemote<health::mojom::PowerObserver> observer) {
+  power_observer_.AddObserver(std::move(observer));
+}
+
 void SystemEventsService::FlushForTesting() {
   bluetooth_observer_.FlushForTesting();
   lid_observer_.FlushForTesting();
+  power_observer_.FlushForTesting();
 }
 
 }  // namespace chromeos

chromeos/components/telemetry_extension_ui/system_events_service.h

@@ -12,6 +12,7 @@
 #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 "chromeos/components/telemetry_extension_ui/power_observer.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
@@ -32,6 +33,9 @@ class SystemEventsService : public health::mojom::SystemEventsService {
   void AddLidObserver(
       mojo::PendingRemote<health::mojom::LidObserver> observer) override;
 
+  void AddPowerObserver(
+      mojo::PendingRemote<health::mojom::PowerObserver> observer) override;
+
   void FlushForTesting();
 
  private:
@@ -39,6 +43,7 @@ class SystemEventsService : public health::mojom::SystemEventsService {
 
   BluetoothObserver bluetooth_observer_;
   LidObserver lid_observer_;
+  PowerObserver power_observer_;
 };
 
 }  // namespace chromeos

chromeos/components/telemetry_extension_ui/system_events_service_unittest.cc

@@ -64,6 +64,25 @@ class MockLidObserver : public health::mojom::LidObserver {
   mojo::Receiver<health::mojom::LidObserver> receiver_;
 };
 
+class MockPowerObserver : public health::mojom::PowerObserver {
+ public:
+  MockPowerObserver() : receiver_{this} {}
+  MockPowerObserver(const MockPowerObserver&) = delete;
+  MockPowerObserver& operator=(const MockPowerObserver&) = delete;
+
+  mojo::PendingRemote<health::mojom::PowerObserver> pending_remote() {
+    return receiver_.BindNewPipeAndPassRemote();
+  }
+
+  MOCK_METHOD(void, OnAcInserted, (), (override));
+  MOCK_METHOD(void, OnAcRemoved, (), (override));
+  MOCK_METHOD(void, OnOsSuspend, (), (override));
+  MOCK_METHOD(void, OnOsResume, (), (override));
+
+ private:
+  mojo::Receiver<health::mojom::PowerObserver> receiver_;
+};
+
 }  // namespace
 
 class SystemEventsServiceTest : public testing::Test {
@@ -76,6 +95,8 @@ class SystemEventsServiceTest : public testing::Test {
         std::make_unique<testing::StrictMock<MockBluetoothObserver>>();
     mock_lid_observer_ =
         std::make_unique<testing::StrictMock<MockLidObserver>>();
+    mock_power_observer_ =
+        std::make_unique<testing::StrictMock<MockPowerObserver>>();
 
     // Force other tasks to be processed.
     cros_healthd::ServiceConnection::GetInstance()->FlushForTesting();
@@ -104,6 +125,10 @@ class SystemEventsServiceTest : public testing::Test {
     return mock_lid_observer_->pending_remote();
   }
 
+  mojo::PendingRemote<health::mojom::PowerObserver> power_observer() const {
+    return mock_power_observer_->pending_remote();
+  }
+
   MockBluetoothObserver* mock_bluetooth_observer() const {
     return mock_bluetooth_observer_.get();
   }
@@ -112,6 +137,10 @@ class SystemEventsServiceTest : public testing::Test {
     return mock_lid_observer_.get();
   }
 
+  MockPowerObserver* mock_power_observer() const {
+    return mock_power_observer_.get();
+  }
+
  private:
   base::test::TaskEnvironment task_environment_;
   mojo::Remote<health::mojom::SystemEventsService>
@@ -120,6 +149,7 @@ class SystemEventsServiceTest : public testing::Test {
   std::unique_ptr<testing::StrictMock<MockBluetoothObserver>>
       mock_bluetooth_observer_;
   std::unique_ptr<testing::StrictMock<MockLidObserver>> mock_lid_observer_;
+  std::unique_ptr<testing::StrictMock<MockPowerObserver>> mock_power_observer_;
 };
 
 // Tests that in case of cros_healthd crash Bluetooth Observer will reconnect.
@@ -197,4 +227,42 @@ TEST_F(SystemEventsServiceTest, LidObserverReconnect) {
   run_loop2.Run();
 }
 
+// Tests that in case of cros_healthd crash Power Observer will reconnect.
+TEST_F(SystemEventsServiceTest, PowerObserverReconnect) {
+  remote_system_events_service()->AddPowerObserver(power_observer());
+
+  base::RunLoop run_loop1;
+  EXPECT_CALL(*mock_power_observer(), OnAcInserted).WillOnce([&run_loop1]() {
+    run_loop1.Quit();
+  });
+  cros_healthd::FakeCrosHealthdClient::Get()->EmitAcInsertedEventForTesting();
+  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 power observer from System Event
+  // 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 power observer gets processed
+  // and observer is bound. After this call, we are sure that power observer
+  // reconnected and we can safely emit events.
+  cros_healthd::ServiceConnection::GetInstance()->FlushForTesting();
+
+  base::RunLoop run_loop2;
+  EXPECT_CALL(*mock_power_observer(), OnAcInserted).WillOnce([&run_loop2]() {
+    run_loop2.Quit();
+  });
+  cros_healthd::FakeCrosHealthdClient::Get()->EmitAcInsertedEventForTesting();
+  run_loop2.Run();
+}
+
 }  // namespace chromeos

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.cc

@@ -495,6 +495,34 @@ void TelemetryExtensionUiBrowserTest::EmitLidOpenedEventPeriodically() {
   }));
 }
 
+void TelemetryExtensionUiBrowserTest::EmitAcInsertedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitAcInsertedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::EmitAcRemovedEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitAcRemovedEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::EmitOsSuspendEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitOsSuspendEventForTesting();
+  }));
+}
+
+void TelemetryExtensionUiBrowserTest::EmitOsResumeEventPeriodically() {
+  RunCallbackPeriodically(base::BindRepeating([] {
+    chromeos::cros_healthd::FakeCrosHealthdClient::Get()
+        ->EmitOsResumeEventForTesting();
+  }));
+}
+
 void TelemetryExtensionUiBrowserTest::RunCallbackPeriodically(
     const base::RepeatingClosure& callback) {
   callback.Run();

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.h

@@ -39,6 +39,11 @@ class TelemetryExtensionUiBrowserTest : public SandboxedWebUiAppTestBase {
   void EmitLidClosedEventPeriodically();
   void EmitLidOpenedEventPeriodically();
 
+  void EmitAcInsertedEventPeriodically();
+  void EmitAcRemovedEventPeriodically();
+  void EmitOsSuspendEventPeriodically();
+  void EmitOsResumeEventPeriodically();
+
  private:
   void RunCallbackPeriodically(const base::RepeatingClosure& callback);
 

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.js

@@ -435,6 +435,38 @@ var TelemetryExtensionUIWithLidOpenedEventBrowserTest =
   }
 }
 
+var TelemetryExtensionUIWithAcInsertedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitAcInsertedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithAcRemovedEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitAcRemovedEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithOsSuspendEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitOsSuspendEventPeriodically();');
+  }
+}
+
+var TelemetryExtensionUIWithOsResumeEventBrowserTest =
+    class extends TelemetryExtensionUIBrowserTest {
+  /** @override */
+  testGenPreamble() {
+    GEN('EmitOsResumeEventPeriodically();');
+  }
+}
+
 // Test cases injected into the untrusted context.
 // See implementations in untrusted_browsertest.js.
 //
@@ -518,6 +550,22 @@ const untrustedTests = [
     'UntrustedLidOpenedEventListener',
     'TelemetryExtensionUIWithLidOpenedEventBrowserTest'
   ],
+  [
+    'UntrustedAcInsertedEventListener',
+    'TelemetryExtensionUIWithAcInsertedEventBrowserTest'
+  ],
+  [
+    'UntrustedAcRemovedEventListener',
+    'TelemetryExtensionUIWithAcRemovedEventBrowserTest'
+  ],
+  [
+    'UntrustedOsSuspendEventListener',
+    'TelemetryExtensionUIWithOsSuspendEventBrowserTest'
+  ],
+  [
+    'UntrustedOsResumeEventListener',
+    'TelemetryExtensionUIWithOsResumeEventBrowserTest'
+  ],
 ].forEach(test => registerUntrustedTest(...test));
 
 /**

chromeos/components/telemetry_extension_ui/test/untrusted_browsertest.js

@@ -499,6 +499,30 @@ UNTRUSTED_TEST('UntrustedLidOpenedEventListener', async () => {
       (resolve) => chromeos.telemetry.addEventListener('lid-opened', resolve));
 });
 
+// Tests that addEventListener receives system ac inserted event.
+UNTRUSTED_TEST('UntrustedAcInsertedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener('ac-inserted', resolve));
+});
+
+// Tests that addEventListener receives system ac removed event.
+UNTRUSTED_TEST('UntrustedAcRemovedEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener('ac-removed', resolve));
+});
+
+// Tests that addEventListener receives system os suspend event.
+UNTRUSTED_TEST('UntrustedOsSuspendEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener('os-suspend', resolve));
+});
+
+// Tests that addEventListener receives system os resume event.
+UNTRUSTED_TEST('UntrustedOsResumeEventListener', async () => {
+  await new Promise(
+      (resolve) => chromeos.telemetry.addEventListener('os-resume', resolve));
+});
+
 // Tests that TelemetryInfo throws an error if category is unknown.
 UNTRUSTED_TEST('UntrustedRequestTelemetryInfoUnknownCategory', async () => {
   let caughtError = {};

chromeos/dbus/cros_healthd/fake_cros_healthd_client.cc

@@ -78,6 +78,27 @@ void FakeCrosHealthdClient::EmitAcInsertedEventForTesting() {
   fake_service_.EmitAcInsertedEventForTesting();
 }
 
+void FakeCrosHealthdClient::EmitAcRemovedEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitAcRemovedEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitOsSuspendEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitOsSuspendEventForTesting();
+}
+
+void FakeCrosHealthdClient::EmitOsResumeEventForTesting() {
+  // Flush the receiver, so any pending observers are registered before the
+  // event is emitted.
+  receiver_.FlushForTesting();
+  fake_service_.EmitOsResumeEventForTesting();
+}
+
 void FakeCrosHealthdClient::EmitAdapterAddedEventForTesting() {
   // Flush the receiver, so any pending observers are registered before the
   // event is emitted.

chromeos/dbus/cros_healthd/fake_cros_healthd_client.h

@@ -65,6 +65,15 @@ class COMPONENT_EXPORT(CROS_HEALTHD) FakeCrosHealthdClient
   // Calls the power event OnAcInserted on all registered power observers.
   void EmitAcInsertedEventForTesting();
 
+  // Calls the power event OnAcRemoved on all registered power observers.
+  void EmitAcRemovedEventForTesting();
+
+  // Calls the power event OnOsSuspend on all registered power observers.
+  void EmitOsSuspendEventForTesting();
+
+  // Calls the power event OnOsResume on all registered power observers.
+  void EmitOsResumeEventForTesting();
+
   // Calls the Bluetooth event OnAdapterAdded on all registered Bluetooth
   // observers.
   void EmitAdapterAddedEventForTesting();

chromeos/dbus/cros_healthd/fake_cros_healthd_service.cc

@@ -283,6 +283,21 @@ void FakeCrosHealthdService::EmitAcInsertedEventForTesting() {
     observer->OnAcInserted();
 }
 
+void FakeCrosHealthdService::EmitAcRemovedEventForTesting() {
+  for (auto& observer : power_observers_)
+    observer->OnAcRemoved();
+}
+
+void FakeCrosHealthdService::EmitOsSuspendEventForTesting() {
+  for (auto& observer : power_observers_)
+    observer->OnOsSuspend();
+}
+
+void FakeCrosHealthdService::EmitOsResumeEventForTesting() {
+  for (auto& observer : power_observers_)
+    observer->OnOsResume();
+}
+
 void FakeCrosHealthdService::EmitAdapterAddedEventForTesting() {
   for (auto& observer : bluetooth_observers_)
     observer->OnAdapterAdded();

chromeos/dbus/cros_healthd/fake_cros_healthd_service.h

@@ -145,6 +145,15 @@ class FakeCrosHealthdService final
   // Calls the power event OnAcInserted for all registered power observers.
   void EmitAcInsertedEventForTesting();
 
+  // Calls the power event OnAcRemoved on all registered power observers.
+  void EmitAcRemovedEventForTesting();
+
+  // Calls the power event OnOsSuspend on all registered power observers.
+  void EmitOsSuspendEventForTesting();
+
+  // Calls the power event OnOsResume on all registered power observers.
+  void EmitOsResumeEventForTesting();
+
   // Calls the Bluetooth event OnAdapterAdded for all registered Bluetooth
   // observers.
   void EmitAdapterAddedEventForTesting();