[Telemetry] Implement management CX interface

Add the Chrome Extension interface definitions for the Management API,
with the first use case “SetAudioGain”.

This is part of a bigger effort to add the Management API to the
Telemetry Extension. For more context visit
go/telemetry-extension-management-audio.

Bug: b/303391740
Test: browser_tests --gtest_filter="TelemetryExtension*"
Test: testing/xvfb.py ./build/lacros/test_runner.py test out_linux_lacros/Release/lacros_chrome_browsertests --gtest_filter="TelemetryExtension*"
Test: testing/xvfb.py ./build/lacros/test_runner.py test out_linux_lacros/Release/lacros_chrome_browsertests --ash-chrome-path-override=lacros_version_skew_tests_v$version/test_ash_chrome --gtest_filter="TelemetryExtension*"
Test: testing/xvfb.py out/lsan/browser_tests --gtest_filter="TelemetryExtension*" --no-sandbox
Change-Id: Ice06241352adbd1cbb97df0fb673ff98169c6e39
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5100330
Reviewed-by: Kerker Yang <kerker@chromium.org>
Commit-Queue: Denny Huang <dennyh@google.com>
Cr-Commit-Position: refs/heads/main@{#1240554}

chrome/browser/chromeos/extensions/telemetry/api/BUILD.gn

@@ -20,6 +20,7 @@ function_registration("api_registration") {
   deps = [
     "diagnostics",
     "events",
+    "management",
     "telemetry",
     "//base",
     "//extensions/common",
@@ -45,6 +46,7 @@ source_set("browser_tests") {
     "common:browser_tests",
     "diagnostics:browser_tests",
     "events:browser_tests",
+    "management:browser_tests",
     "routines:browser_tests",
     "telemetry:browser_tests",
   ]

chrome/browser/chromeos/extensions/telemetry/api/common/base_telemetry_extension_api_guard_function_browsertest.cc

@@ -630,6 +630,21 @@ std::string GetServiceWorkerForError(const std::string& error) {
         );
         chrome.test.succeed();
       },
+      // Management APIs.
+      async function setAudioGain() {
+        await chrome.test.assertPromiseRejects(
+            chrome.os.management.setAudioGain(
+              {
+                nodeId: 1,
+                gain: 100,
+              }
+            ),
+            'Error: Unauthorized access to ' +
+            'chrome.os.management.setAudioGain. ' +
+            '%s'
+        );
+        chrome.test.succeed();
+      },
     ];
 
     chrome.test.runTests([
@@ -644,7 +659,8 @@ std::string GetServiceWorkerForError(const std::string& error) {
         apiNames = [
           ...getMethods(chrome.os.telemetry).sort(),
           ...getMethods(chrome.os.diagnostics).sort(),
-          ...getMethods(chrome.os.events).sort()
+          ...getMethods(chrome.os.events).sort(),
+          ...getMethods(chrome.os.management).sort()
         ];
         chrome.test.assertEq(getTestNames(tests), apiNames);
         chrome.test.succeed();

chrome/browser/chromeos/extensions/telemetry/api/common/base_telemetry_extension_browser_test.cc

@@ -90,6 +90,7 @@ std::string BaseTelemetryExtensionBrowserTest::GetManifestFile(
           "os.bluetooth_peripherals_info",
           "os.diagnostics",
           "os.events",
+          "os.management.audio",
           "os.telemetry",
           "os.telemetry.serial_number",
           "os.telemetry.network_info"

chrome/browser/chromeos/extensions/telemetry/api/management/BUILD.gn

@@ -0,0 +1,79 @@
+# Copyright 2023 The Chromium Authors
+# Use of this source code is governed by a BSD - style license that can be
+# found in the LICENSE file.
+
+import("//chrome/common/chromeos/extensions/api/api_sources.gni")
+import("//extensions/buildflags/buildflags.gni")
+
+assert(enable_extensions,
+       "Cannot depend on extensions because enable_extensions=false.")
+
+source_set("management") {
+  sources = [
+    "management_api.cc",
+    "management_api.h",
+    "remote_telemetry_management_service_strategy.cc",
+    "remote_telemetry_management_service_strategy.h",
+  ]
+
+  deps = [
+    "//base",
+    "//build:chromeos_buildflags",
+    "//chrome/browser/chromeos/extensions/telemetry/api/common",
+    "//chrome/browser/extensions",
+    "//chrome/common/chromeos/extensions/api",
+    "//chromeos/crosapi/mojom",
+    "//extensions/browser",
+    "//extensions/common",
+    "//mojo/public/cpp/bindings",
+    "//third_party/abseil-cpp:absl",
+  ]
+
+  public_deps = [ "//extensions/browser" ]
+
+  if (is_chromeos_ash) {
+    deps += [ "//chrome/browser/ash/telemetry_extension/management" ]
+  }
+
+  if (is_chromeos_lacros) {
+    deps += [ "//chromeos/lacros" ]
+  }
+}
+
+source_set("browser_tests") {
+  testonly = true
+  defines = [ "HAS_OUT_OF_PROC_TEST_RUNNER" ]
+  sources = [
+    "fake_telemetry_management_service.cc",
+    "fake_telemetry_management_service.h",
+    "management_api_browsertest.cc",
+  ]
+
+  deps = [
+    ":management",
+    "//base",
+    "//build:chromeos_buildflags",
+    "//chrome/browser/chromeos/extensions/telemetry/api/common:test_support",
+    "//chrome/browser/chromeos/telemetry:test_support",
+    "//chromeos/crosapi/mojom",
+    "//content/test:test_support",
+    "//extensions/common",
+    "//mojo/public/cpp/bindings",
+    "//testing/gtest",
+  ]
+
+  data = [ "//chrome/test/data" ]
+
+  if (is_chromeos_ash) {
+    sources += [
+      "fake_telemetry_management_service_factory.cc",
+      "fake_telemetry_management_service_factory.h",
+    ]
+
+    deps += [ "//chrome/browser/ash/telemetry_extension/management" ]
+  }
+
+  if (is_chromeos_lacros) {
+    deps += [ "//chromeos/lacros" ]
+  }
+}

chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service.cc

@@ -0,0 +1,40 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service.h"
+
+#include <utility>
+
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+
+namespace chromeos {
+
+namespace {
+namespace crosapi = ::crosapi::mojom;
+}  // namespace
+
+FakeTelemetryManagementService::FakeTelemetryManagementService() = default;
+
+FakeTelemetryManagementService::~FakeTelemetryManagementService() = default;
+
+void FakeTelemetryManagementService::BindPendingReceiver(
+    mojo::PendingReceiver<crosapi::TelemetryManagementService> receiver) {
+  receiver_.Bind(std::move(receiver));
+}
+
+mojo::PendingRemote<crosapi::TelemetryManagementService>
+FakeTelemetryManagementService::BindNewPipeAndPassRemote() {
+  return receiver_.BindNewPipeAndPassRemote();
+}
+
+void FakeTelemetryManagementService::SetAudioGain(
+    uint64_t node_id,
+    int32_t gain,
+    SetAudioGainCallback callback) {
+  std::move(callback).Run();
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service.h

@@ -0,0 +1,43 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_H_
+#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_H_
+
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+
+namespace chromeos {
+
+class FakeTelemetryManagementService
+    : public crosapi::mojom::TelemetryManagementService {
+ public:
+  FakeTelemetryManagementService();
+  FakeTelemetryManagementService(const FakeTelemetryManagementService&) =
+      delete;
+  FakeTelemetryManagementService& operator=(
+      const FakeTelemetryManagementService&) = delete;
+  ~FakeTelemetryManagementService() override;
+
+  void BindPendingReceiver(
+      mojo::PendingReceiver<crosapi::mojom::TelemetryManagementService>
+          receiver);
+
+  mojo::PendingRemote<crosapi::mojom::TelemetryManagementService>
+  BindNewPipeAndPassRemote();
+
+  // TelemetryManagementService:
+  void SetAudioGain(uint64_t node_id,
+                    int32_t gain,
+                    SetAudioGainCallback callback) override;
+
+ private:
+  mojo::Receiver<crosapi::mojom::TelemetryManagementService> receiver_{this};
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_H_

chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service_factory.cc

@@ -0,0 +1,40 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service_factory.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/check.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+
+namespace chromeos {
+
+namespace {
+
+namespace crosapi = ::crosapi::mojom;
+
+}  // namespace
+
+FakeTelemetryManagementServiceFactory::FakeTelemetryManagementServiceFactory() =
+    default;
+FakeTelemetryManagementServiceFactory::
+    ~FakeTelemetryManagementServiceFactory() = default;
+
+void FakeTelemetryManagementServiceFactory::SetCreateInstanceResponse(
+    std::unique_ptr<FakeTelemetryManagementService> fake_service) {
+  fake_service_ = std::move(fake_service);
+}
+
+std::unique_ptr<crosapi::TelemetryManagementService>
+FakeTelemetryManagementServiceFactory::CreateInstance(
+    mojo::PendingReceiver<crosapi::TelemetryManagementService> receiver) {
+  DCHECK(fake_service_);
+  fake_service_->BindPendingReceiver(std::move(receiver));
+  return std::move(fake_service_);
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service_factory.h

@@ -0,0 +1,38 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_FACTORY_H_
+#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_FACTORY_H_
+
+#include <memory>
+
+#include "chrome/browser/ash/telemetry_extension/management/telemetry_management_service_ash.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+
+namespace chromeos {
+
+class FakeTelemetryManagementServiceFactory
+    : public ash::TelemetryManagementServiceAsh::Factory {
+ public:
+  FakeTelemetryManagementServiceFactory();
+  ~FakeTelemetryManagementServiceFactory() override;
+
+  void SetCreateInstanceResponse(
+      std::unique_ptr<FakeTelemetryManagementService> fake_service);
+
+ protected:
+  // TelemetryManagementServiceAsh::Factory:
+  std::unique_ptr<crosapi::mojom::TelemetryManagementService> CreateInstance(
+      mojo::PendingReceiver<crosapi::mojom::TelemetryManagementService>
+          receiver) override;
+
+ private:
+  std::unique_ptr<FakeTelemetryManagementService> fake_service_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_FAKE_TELEMETRY_MANAGEMENT_SERVICE_FACTORY_H_

chrome/browser/chromeos/extensions/telemetry/api/management/management_api.cc

@@ -0,0 +1,79 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/management_api.h"
+
+#include <inttypes.h>
+
+#include <memory>
+#include <utility>
+
+#include "base/functional/bind.h"
+#include "base/functional/callback.h"
+#include "build/chromeos_buildflags.h"
+#include "chrome/common/chromeos/extensions/api/management.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "extensions/common/permissions/permissions_data.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+
+namespace chromeos {
+
+namespace {
+
+namespace cx_manage = api::os_management;
+namespace crosapi = ::crosapi::mojom;
+
+}  // namespace
+
+// ManagementApiFunctionBase ---------------------------------------------------
+
+ManagementApiFunctionBase::ManagementApiFunctionBase()
+    : remote_telemetry_management_service_strategy_(
+          RemoteTelemetryManagementServiceStrategy::Create()) {}
+
+ManagementApiFunctionBase::~ManagementApiFunctionBase() = default;
+
+mojo::Remote<crosapi::TelemetryManagementService>&
+ManagementApiFunctionBase::GetRemoteService() {
+  DCHECK(remote_telemetry_management_service_strategy_);
+  return remote_telemetry_management_service_strategy_->GetRemoteService();
+}
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+bool ManagementApiFunctionBase::IsCrosApiAvailable() {
+  return remote_telemetry_management_service_strategy_ != nullptr;
+}
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+
+template <class Params>
+absl::optional<Params> ManagementApiFunctionBase::GetParams() {
+  auto params = Params::Create(args());
+  if (!params) {
+    SetBadMessage();
+    Respond(BadMessage());
+  }
+
+  return params;
+}
+
+// OsManagementSetAudioGainFunction --------------------------------------------
+
+void OsManagementSetAudioGainFunction::RunIfAllowed() {
+  // Clamping |gain| to [0, 100] is done in Telemetry Extension Service
+  // `TelemetryManagementServiceAsh::SetAudioGain`.
+  const auto params = GetParams<cx_manage::SetAudioGain::Params>();
+  if (!params) {
+    return;
+  }
+
+  auto cb = base::BindOnce(&OsManagementSetAudioGainFunction::OnResult, this);
+  GetRemoteService()->SetAudioGain(params.value().args.node_id,
+                                   params.value().args.gain, std::move(cb));
+}
+
+void OsManagementSetAudioGainFunction::OnResult() {
+  Respond(NoArguments());
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/extensions/telemetry/api/management/management_api.h

@@ -0,0 +1,64 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_MANAGEMENT_API_H_
+#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_MANAGEMENT_API_H_
+
+#include <memory>
+
+#include "build/chromeos_buildflags.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/common/base_telemetry_extension_api_guard_function.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/remote_telemetry_management_service_strategy.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "extensions/browser/extension_function.h"
+#include "extensions/browser/extension_function_histogram_value.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+namespace chromeos {
+
+class ManagementApiFunctionBase
+    : public BaseTelemetryExtensionApiGuardFunction {
+ public:
+  ManagementApiFunctionBase();
+
+  ManagementApiFunctionBase(const ManagementApiFunctionBase&) = delete;
+  ManagementApiFunctionBase& operator=(const ManagementApiFunctionBase&) =
+      delete;
+
+ protected:
+  ~ManagementApiFunctionBase() override;
+
+  mojo::Remote<crosapi::mojom::TelemetryManagementService>& GetRemoteService();
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+  bool IsCrosApiAvailable() override;
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+
+  // Gets the parameters passed to the JavaScript call and tries to convert it
+  // to the `Params` type. If the `Params` can't be created, this resolves the
+  // corresponding JavaScript call with an error and returns `nullptr`.
+  template <class Params>
+  absl::optional<Params> GetParams();
+
+ private:
+  std::unique_ptr<RemoteTelemetryManagementServiceStrategy>
+      remote_telemetry_management_service_strategy_;
+};
+
+class OsManagementSetAudioGainFunction : public ManagementApiFunctionBase {
+  DECLARE_EXTENSION_FUNCTION("os.management.setAudioGain",
+                             OS_MANAGEMENT_SETAUDIOGAIN)
+
+ private:
+  ~OsManagementSetAudioGainFunction() override = default;
+
+  // BaseTelemetryExtensionApiGuardFunction:
+  void RunIfAllowed() override;
+
+  void OnResult();
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_MANAGEMENT_API_H_

chrome/browser/chromeos/extensions/telemetry/api/management/management_api_browsertest.cc

@@ -0,0 +1,101 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "base/check_deref.h"
+#include "base/test/bind.h"
+#include "build/chromeos_buildflags.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/common/base_telemetry_extension_browser_test.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "content/public/test/browser_test.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+#include "chrome/browser/ash/telemetry_extension/management/telemetry_management_service_ash.h"
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/fake_telemetry_management_service_factory.h"
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+#include "chromeos/lacros/lacros_service.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+
+namespace chromeos {
+
+namespace {
+
+namespace crosapi = ::crosapi::mojom;
+
+}  // namespace
+
+class TelemetryExtensionManagementApiBrowserTest
+    : public BaseTelemetryExtensionBrowserTest {
+ public:
+  TelemetryExtensionManagementApiBrowserTest() {
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+    ash::TelemetryManagementServiceAsh::Factory::SetForTesting(
+        &fake_telemetry_management_service_factory_);
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+  }
+
+  ~TelemetryExtensionManagementApiBrowserTest() override = default;
+
+  TelemetryExtensionManagementApiBrowserTest(
+      const TelemetryExtensionManagementApiBrowserTest&) = delete;
+  TelemetryExtensionManagementApiBrowserTest& operator=(
+      const TelemetryExtensionManagementApiBrowserTest&) = delete;
+
+  void SetServiceForTesting(std::unique_ptr<FakeTelemetryManagementService>
+                                fake_telemetry_management_service_impl) {
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+    fake_telemetry_management_service_factory_.SetCreateInstanceResponse(
+        std::move(fake_telemetry_management_service_impl));
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+    fake_telemetry_management_service_impl_ =
+        std::move(fake_telemetry_management_service_impl);
+    // Replace the production TelemetryManagementService with a fake for
+    // testing.
+    chromeos::LacrosService::Get()->InjectRemoteForTesting(
+        fake_telemetry_management_service_impl_->BindNewPipeAndPassRemote());
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+  }
+
+ private:
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+  FakeTelemetryManagementServiceFactory
+      fake_telemetry_management_service_factory_;
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+  std::unique_ptr<FakeTelemetryManagementService>
+      fake_telemetry_management_service_impl_;
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+};
+
+IN_PROC_BROWSER_TEST_F(TelemetryExtensionManagementApiBrowserTest,
+                       SetAudioGain) {
+  {
+    auto fake_service_impl = std::make_unique<FakeTelemetryManagementService>();
+    SetServiceForTesting(std::move(fake_service_impl));
+  }
+
+  CreateExtensionAndRunServiceWorker(R"(
+    chrome.test.runTests([
+      async function setAudioGain() {
+        await chrome.os.management.setAudioGain({
+          nodeId: 1,
+          gain: 100,
+        });
+        chrome.test.succeed();
+      }
+    ]);
+    )");
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/extensions/telemetry/api/management/remote_telemetry_management_service_strategy.cc

@@ -0,0 +1,89 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/extensions/telemetry/api/management/remote_telemetry_management_service_strategy.h"
+
+#include <memory>
+
+#include "build/chromeos_buildflags.h"
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+#include "chrome/browser/ash/telemetry_extension/management/telemetry_management_service_ash.h"
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+#include "chromeos/lacros/lacros_service.h"
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+
+namespace chromeos {
+
+namespace {
+
+namespace crosapi = ::crosapi::mojom;
+
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+class RemoteTelemetryManagementServiceStrategyAsh
+    : public RemoteTelemetryManagementServiceStrategy {
+ public:
+  RemoteTelemetryManagementServiceStrategyAsh()
+      : management_service_(ash::TelemetryManagementServiceAsh::Factory::Create(
+            remote_management_service_.BindNewPipeAndPassReceiver())) {}
+
+  ~RemoteTelemetryManagementServiceStrategyAsh() override = default;
+
+  // RemoteTelemetryManagementServiceStrategy override:
+  mojo::Remote<crosapi::TelemetryManagementService>& GetRemoteService()
+      override {
+    return remote_management_service_;
+  }
+
+ private:
+  mojo::Remote<crosapi::TelemetryManagementService> remote_management_service_;
+
+  std::unique_ptr<crosapi::TelemetryManagementService> management_service_;
+};
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+class RemoteTelemetryManagementServiceStrategyLacros
+    : public RemoteTelemetryManagementServiceStrategy {
+ public:
+  RemoteTelemetryManagementServiceStrategyLacros() = default;
+
+  ~RemoteTelemetryManagementServiceStrategyLacros() override = default;
+
+  // RemoteTelemetryManagementServiceStrategy:
+  mojo::Remote<crosapi::TelemetryManagementService>& GetRemoteService()
+      override {
+    return LacrosService::Get()
+        ->GetRemote<crosapi::TelemetryManagementService>();
+  }
+};
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+
+}  // namespace
+
+// static
+std::unique_ptr<RemoteTelemetryManagementServiceStrategy>
+RemoteTelemetryManagementServiceStrategy::Create() {
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+  return std::make_unique<RemoteTelemetryManagementServiceStrategyAsh>();
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+  if (!LacrosService::Get()
+           ->IsAvailable<crosapi::TelemetryManagementService>()) {
+    return nullptr;
+  }
+  return std::make_unique<RemoteTelemetryManagementServiceStrategyLacros>();
+#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
+}
+
+RemoteTelemetryManagementServiceStrategy::
+    RemoteTelemetryManagementServiceStrategy() = default;
+RemoteTelemetryManagementServiceStrategy::
+    ~RemoteTelemetryManagementServiceStrategy() = default;
+
+}  // namespace chromeos

chrome/browser/chromeos/extensions/telemetry/api/management/remote_telemetry_management_service_strategy.h

@@ -0,0 +1,37 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_REMOTE_TELEMETRY_MANAGEMENT_SERVICE_STRATEGY_H_
+#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_REMOTE_TELEMETRY_MANAGEMENT_SERVICE_STRATEGY_H_
+
+#include <memory>
+
+#include "chromeos/crosapi/mojom/telemetry_management_service.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+namespace chromeos {
+
+// A class that provides an interface for accessing a management service mojo
+// remote. Allows for multiple implementations depending on whether this is
+// running in Ash or LaCros.
+class RemoteTelemetryManagementServiceStrategy {
+ public:
+  static std::unique_ptr<RemoteTelemetryManagementServiceStrategy> Create();
+
+  RemoteTelemetryManagementServiceStrategy(
+      const RemoteTelemetryManagementServiceStrategy&) = delete;
+  RemoteTelemetryManagementServiceStrategy& operator=(
+      const RemoteTelemetryManagementServiceStrategy&) = delete;
+  virtual ~RemoteTelemetryManagementServiceStrategy();
+
+  virtual mojo::Remote<crosapi::mojom::TelemetryManagementService>&
+  GetRemoteService() = 0;
+
+ protected:
+  RemoteTelemetryManagementServiceStrategy();
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_TELEMETRY_API_MANAGEMENT_REMOTE_TELEMETRY_MANAGEMENT_SERVICE_STRATEGY_H_

chrome/common/chromeos/extensions/api/_api_features.json

@@ -33,6 +33,25 @@
     ],
     "channel": "stable"
   },
+  "os.management": {
+    // Right now Management API is limited to audio control.
+    "dependencies": [
+      "permission:os.management.audio"
+    ],
+    "contexts": [
+      "blessed_extension"
+    ],
+    "platforms": [
+      "chromeos",
+      "lacros"
+    ],
+    "channel": "stable"
+  },
+  "os.management.setAudioGain": {
+    "dependencies": [
+      "permission:os.management.audio"
+    ]
+  },
   "os.telemetry": {
     "dependencies": [
       "permission:os.telemetry"

chrome/common/chromeos/extensions/api/api_sources.gni

@@ -11,6 +11,7 @@ assert(enable_extensions)
 schema_sources_ = [
   "diagnostics.idl",
   "events.idl",
+  "management.idl",
   "telemetry.idl",
 ]
 

chrome/common/chromeos/extensions/api/management.idl

@@ -0,0 +1,32 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Use the <code>chrome.os.management</code> API to manage ChromeOS settings.
+[implemented_in = "chrome/browser/chromeos/extensions/telemetry/api/management/management_api.h", modernised_enums]
+namespace os.management {
+// Note: Please update documentation as well when this interface is changed.
+// The documentation lives here: //docs/telemetry_extension/api_overview.md.
+// LINT.IfChange
+
+  dictionary SetAudioGainArguments {
+      // Node id of the audio device to be configured.
+      long nodeId;
+      // Target gain percent in [0, 100]. Sets to 0 or 100 if outside.
+      long gain;
+  };
+
+  callback VoidCallback = void();
+
+  interface Functions {
+      // Sets the specified input audio device's gain to value. No-op if
+      // |args.nodeId| is invalid.
+      [supportsPromises] static void setAudioGain(
+          SetAudioGainArguments args, VoidCallback callback);
+  };
+
+  // LINT.ThenChange(//docs/telemetry_extension/api_overview.md)
+  // The following is an empty definition, since the IDL compiler only accepts
+  // comments over valid definitions.
+  callback EOF = void();
+};

docs/telemetry_extension/api_overview.md

@@ -1,8 +1,7 @@
 # Telemetry Extension API overview
 
 This document gives a function-level documentation of the Telemetry Extension
-API. It is separated in the three namespaces **telemetry**, **diagnostics**
-and **events**.
+API. It is separated in the three namespaces **telemetry**, **diagnostics**, **events** and **management**.
 
 [TOC]
 
@@ -1059,3 +1058,19 @@ Source:
 | getAudioInfo | () => Promise<AudioInfo\> | `os.telemetry` | M111 |
 | getMarketingInfo | () => Promise<MarketingInfo\> | `os.telemetry` | M111 |
 | getUsbBusInfo | () => Promise<UsbDevicesInfo\> | `os.telemetry`, `os.attached_device_info` | M114 |
+
+# Management
+
+## Types
+
+### SetAudioGainArguments
+| Property Name | Type | Description |
+------------ | ------- | ----------- |
+| nodeId | number | Node id of the audio device to be configured |
+| gain | number | Target gain percent in [0, 100]. Sets to 0 or 100 if outside |
+
+## Functions
+
+| Function Name | Definition | Permission needed to access | Released in Chrome version | Description |
+------------ | ------------- | ------------- | ------------- | ------------- |
+| setAudioGain | (args: SetAudioGainArguments) => Promise<void\> | `os.management.audio` | M122 | Sets the specified input audio device's gain to value. No-op if `args.nodeId` is invalid |