Create mojo interface for power manager.

Ash will continue talking to the power manager daemon via DBus,
while providing a mojo service that Chrome can connect to for its
power manager needs.

The mojo interface is only used by client code that explicitly
opts in, and only when a specific feature flag is passed.

This CL partially implements the Mojo interface as it's used by
BrightnessMonitor, which is to say, it implements very little.

Change-Id: Id0b286a690d1833b1090960cf31edfbe66124b24
Bug: 644348
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1531466
Commit-Queue: Evan Stade <estade@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#652727}

ash/BUILD.gn

@@ -1358,6 +1358,8 @@ component("ash") {
     "//chromeos/services/assistant/public:feature_flags",
     "//chromeos/services/assistant/public/mojom",
     "//chromeos/services/multidevice_setup/public/mojom",
+    "//chromeos/services/power/public/cpp:controller",
+    "//chromeos/services/power/public/mojom",
     "//chromeos/settings",
     "//chromeos/strings",
     "//chromeos/system",

ash/DEPS

@@ -75,6 +75,7 @@ include_rules = [
   "+chromeos/services/assistant/public" ,
   "+chromeos/services/assistant/test_support",
   "+chromeos/services/multidevice_setup/public",
+  "+chromeos/services/power/public",
   # TODO(https://crbug.com/644361): Eliminate this.
   "+chromeos/settings/timezone_settings.h",
   "+chromeos/strings",

ash/mojo_interface_factory.cc

@@ -54,6 +54,7 @@
 #include "base/lazy_instance.h"
 #include "base/single_thread_task_runner.h"
 #include "chromeos/constants/chromeos_switches.h"
+#include "chromeos/services/power/public/cpp/power_manager_mojo_controller.h"
 #include "ui/keyboard/keyboard_controller.h"
 
 namespace ash {
@@ -272,6 +273,12 @@ void BindSplitViewRequestOnMainThread(
   Shell::Get()->split_view_controller()->BindRequest(std::move(request));
 }
 
+void BindPowerManagerControllerRequestOnMainThread(
+    chromeos::power::mojom::PowerManagerControllerRequest request) {
+  Shell::Get()->power_manager_mojo_controller()->BindRequest(
+      std::move(request));
+}
+
 }  // namespace
 
 void RegisterInterfaces(
@@ -403,6 +410,9 @@ void RegisterInterfaces(
                          main_thread_task_runner);
   registry->AddInterface(base::BindRepeating(&BindSplitViewRequestOnMainThread),
                          main_thread_task_runner);
+  registry->AddInterface(
+      base::BindRepeating(&BindPowerManagerControllerRequestOnMainThread),
+      main_thread_task_runner);
 
   // Inject additional optional interfaces.
   if (g_register_interfaces_callback.Get()) {

ash/public/cpp/BUILD.gn

@@ -178,6 +178,7 @@ source_set("manifest") {
     "//ash/public/interfaces:interfaces_internal",
     "//base",
     "//chromeos/services/multidevice_setup/public/mojom",
+    "//chromeos/services/power/public/mojom",
     "//services/content/public/mojom",
     "//services/data_decoder/public/mojom",
     "//services/device/public/mojom",

ash/public/cpp/DEPS

 include_rules = [
   "+chromeos/constants",
+  "+chromeos/services",
   "+components/prefs",
   "+services/data_decoder/public",
   "+services/device/public",

ash/public/cpp/manifest.cc

@@ -44,6 +44,7 @@
 #include "ash/public/interfaces/wallpaper.mojom.h"
 #include "base/no_destructor.h"
 #include "chromeos/services/multidevice_setup/public/mojom/constants.mojom.h"
+#include "chromeos/services/power/public/mojom/power_manager.mojom.h"
 #include "services/content/public/mojom/constants.mojom.h"
 #include "services/data_decoder/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/constants.mojom.h"
@@ -75,6 +76,7 @@ const service_manager::Manifest& GetManifest() {
           .ExposeCapability(
               "system_ui",
               service_manager::Manifest::InterfaceList<
+                  chromeos::power::mojom::PowerManagerController,
                   mojom::AcceleratorController, mojom::AccessibilityController,
                   mojom::AccessibilityFocusRingController,
                   mojom::AppListController, mojom::ArcCustomTabController,

ash/shell.cc

@@ -175,8 +175,10 @@
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
 #include "base/trace_event/trace_event.h"
+#include "chromeos/constants/chromeos_features.h"
 #include "chromeos/dbus/initialize_dbus_client.h"
 #include "chromeos/dbus/power/power_policy_controller.h"
+#include "chromeos/services/power/public/cpp/power_manager_mojo_controller.h"
 #include "chromeos/system/devicemode.h"
 #include "components/exo/file_helper.h"
 #include "components/prefs/pref_registry_simple.h"
@@ -679,6 +681,11 @@ Shell::Shell(std::unique_ptr<ShellDelegate> shell_delegate,
           {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
 
+  if (base::FeatureList::IsEnabled(chromeos::features::kMojoDBusRelay)) {
+    power_manager_mojo_controller_ =
+        std::make_unique<chromeos::PowerManagerMojoController>();
+  }
+
   login_screen_controller_ =
       std::make_unique<LoginScreenController>(system_tray_notifier_.get());
   display_manager_.reset(ScreenAsh::CreateDisplayManager());
@@ -949,6 +956,8 @@ Shell::~Shell() {
   // before it.
   detachable_base_handler_.reset();
 
+  power_manager_mojo_controller_.reset();
+
   // MediaNotificationController depends on MessageCenter and must be destructed
   // before it.
   media_notification_controller_.reset();

ash/shell.h

@@ -35,6 +35,10 @@ class RootWindow;
 class Window;
 }  // namespace aura
 
+namespace chromeos {
+class PowerManagerMojoController;
+}
+
 namespace dbus {
 class Bus;
 }
@@ -468,6 +472,9 @@ class ASH_EXPORT Shell : public SessionObserver,
   NewWindowController* new_window_controller() {
     return new_window_controller_.get();
   }
+  chromeos::PowerManagerMojoController* power_manager_mojo_controller() {
+    return power_manager_mojo_controller_.get();
+  }
   NightLightController* night_light_controller();
   NoteTakingController* note_taking_controller() {
     return note_taking_controller_.get();
@@ -763,6 +770,8 @@ class ASH_EXPORT Shell : public SessionObserver,
   std::unique_ptr<MultiDeviceNotificationPresenter>
       multidevice_notification_presenter_;
   std::unique_ptr<NewWindowController> new_window_controller_;
+  std::unique_ptr<chromeos::PowerManagerMojoController>
+      power_manager_mojo_controller_;
   std::unique_ptr<ResizeShadowController> resize_shadow_controller_;
   std::unique_ptr<SessionController> session_controller_;
   std::unique_ptr<NightLightController> night_light_controller_;

chrome/browser/chromeos/BUILD.gn

@@ -128,6 +128,8 @@ source_set("chromeos") {
     "//chromeos/services/multidevice_setup/public/cpp:auth_token_validator",
     "//chromeos/services/multidevice_setup/public/cpp:oobe_completion_tracker",
     "//chromeos/services/multidevice_setup/public/cpp:prefs",
+    "//chromeos/services/power/public/cpp:client",
+    "//chromeos/services/power/public/mojom",
     "//chromeos/services/secure_channel/public/cpp/client",
     "//chromeos/settings",
     "//chromeos/system",

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -136,6 +136,7 @@
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/cryptohome/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power/power_manager_client.h"
 #include "chromeos/dbus/power/power_policy_controller.h"
 #include "chromeos/dbus/services/cros_dbus_service.h"
 #include "chromeos/dbus/session_manager/session_manager_client.h"
@@ -147,6 +148,7 @@
 #include "chromeos/network/network_cert_loader.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/portal_detector/network_portal_detector_stub.h"
+#include "chromeos/services/power/public/cpp/power_manager_mojo_client.h"
 #include "chromeos/system/statistics_provider.h"
 #include "chromeos/tpm/install_attributes.h"
 #include "chromeos/tpm/tpm_token_loader.h"
@@ -569,6 +571,11 @@ int ChromeBrowserMainPartsChromeos::PreEarlyInitialization() {
   // DBus is initialized in ChromeMainDelegate::PostEarlyInitialization().
   CHECK(DBusThreadManager::IsInitialized());
 
+  if (base::FeatureList::IsEnabled(chromeos::features::kMojoDBusRelay)) {
+    power_manager_mojo_client_ =
+        std::make_unique<chromeos::PowerManagerMojoClient>();
+  }
+
   if (!base::SysInfo::IsRunningOnChromeOS() &&
       parsed_command_line().HasSwitch(
           switches::kFakeDriveFsLauncherChrootPath) &&
@@ -608,6 +615,17 @@ void ChromeBrowserMainPartsChromeos::PostMainMessageLoopStart() {
   ChromeBrowserMainPartsLinux::PostMainMessageLoopStart();
 }
 
+void ChromeBrowserMainPartsChromeos::ServiceManagerConnectionStarted(
+    content::ServiceManagerConnection* connection) {
+  if (base::FeatureList::IsEnabled(chromeos::features::kMojoDBusRelay)) {
+    connection->GetConnector()->BindInterface(
+        ash::mojom::kServiceName, power_manager_mojo_client_->interface_ptr());
+    power_manager_mojo_client_->InitAfterInterfaceBound();
+  }
+
+  ChromeBrowserMainPartsLinux::ServiceManagerConnectionStarted(connection);
+}
+
 // Threads are initialized between MainMessageLoopStart and MainMessageLoopRun.
 // about_flags settings are applied in ChromeBrowserMainParts::PreCreateThreads.
 void ChromeBrowserMainPartsChromeos::PreMainMessageLoopRun() {
@@ -951,7 +969,7 @@ void ChromeBrowserMainPartsChromeos::PostProfileInit() {
       std::make_unique<FreezerCgroupProcessManager>());
 
   power_metrics_reporter_ = std::make_unique<PowerMetricsReporter>(
-      PowerManagerClient::Get(), g_browser_process->local_state());
+      chromeos::PowerManagerClient::Get(), g_browser_process->local_state());
 
   g_browser_process->platform_part()->InitializeAutomaticRebootManager();
   user_removal_manager::RemoveUsersIfNeeded();

chrome/browser/chromeos/chrome_browser_main_chromeos.h

@@ -49,6 +49,7 @@ class LowDiskNotification;
 class NetworkChangeManagerClient;
 class NetworkPrefStateObserver;
 class NetworkThrottlingObserver;
+class PowerManagerMojoClient;
 class PowerMetricsReporter;
 class RendererFreezer;
 class SchedulerConfigurationManager;
@@ -93,6 +94,8 @@ class ChromeBrowserMainPartsChromeos : public ChromeBrowserMainPartsLinux {
   int PreEarlyInitialization() override;
   void PreMainMessageLoopStart() override;
   void PostMainMessageLoopStart() override;
+  void ServiceManagerConnectionStarted(
+      content::ServiceManagerConnection* connection) override;
   void PreMainMessageLoopRun() override;
 
   // Stages called from PreMainMessageLoopRun.
@@ -163,6 +166,8 @@ class ChromeBrowserMainPartsChromeos : public ChromeBrowserMainPartsLinux {
   std::unique_ptr<SchedulerConfigurationManager>
       scheduler_configuration_manager_;
 
+  std::unique_ptr<chromeos::PowerManagerMojoClient> power_manager_mojo_client_;
+
   std::unique_ptr<CrosUsbDetector> cros_usb_detector_;
   std::unique_ptr<DiagnosticsdManager> diagnosticsd_manager_;
 

chrome/browser/chromeos/power/auto_screen_brightness/brightness_monitor_impl.cc

@@ -16,6 +16,7 @@
 #include "chromeos/constants/chromeos_features.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager/backlight.pb.h"
+#include "chromeos/services/power/public/cpp/power_manager_mojo_client.h"
 
 namespace chromeos {
 namespace power {
@@ -23,15 +24,11 @@ namespace auto_screen_brightness {
 
 constexpr base::TimeDelta BrightnessMonitorImpl::kBrightnessSampleDelay;
 
-BrightnessMonitorImpl::BrightnessMonitorImpl(
-    chromeos::PowerManagerClient* const power_manager_client)
-    : power_manager_client_observer_(this),
-      power_manager_client_(power_manager_client),
-      weak_ptr_factory_(this) {
-  DCHECK(power_manager_client);
-  power_manager_client_observer_.Add(power_manager_client);
+BrightnessMonitorImpl::BrightnessMonitorImpl() {
+  power_manager_client_observer_.Add(chromeos::PowerManagerMojoClient::Get());
 
-  power_manager_client_->WaitForServiceToBeAvailable(
+  // TODO(estade): use Mojo.
+  chromeos::PowerManagerClient::Get()->WaitForServiceToBeAvailable(
       base::BindOnce(&BrightnessMonitorImpl::OnPowerManagerServiceAvailable,
                      weak_ptr_factory_.GetWeakPtr()));
 
@@ -115,7 +112,7 @@ void BrightnessMonitorImpl::OnPowerManagerServiceAvailable(
     OnInitializationComplete();
     return;
   }
-  power_manager_client_->GetScreenBrightnessPercent(
+  chromeos::PowerManagerMojoClient::Get()->GetScreenBrightnessPercent(
       base::BindOnce(&BrightnessMonitorImpl::OnReceiveInitialBrightnessPercent,
                      weak_ptr_factory_.GetWeakPtr()));
 }

chrome/browser/chromeos/power/auto_screen_brightness/brightness_monitor_impl.h

@@ -34,9 +34,7 @@ class BrightnessMonitorImpl : public BrightnessMonitor,
   static constexpr base::TimeDelta kBrightnessSampleDelay =
       base::TimeDelta::FromSeconds(5);
 
-  // PowerManagerClient must outlive BrightnessMonitorImpl.
-  explicit BrightnessMonitorImpl(
-      chromeos::PowerManagerClient* power_manager_client);
+  BrightnessMonitorImpl();
   ~BrightnessMonitorImpl() override;
 
   // BrightnessMonitor overrides:
@@ -75,8 +73,7 @@ class BrightnessMonitorImpl : public BrightnessMonitor,
 
   ScopedObserver<chromeos::PowerManagerClient,
                  chromeos::PowerManagerClient::Observer>
-      power_manager_client_observer_;
-  chromeos::PowerManagerClient* const power_manager_client_;
+      power_manager_client_observer_{this};
 
   // Delay after user brightness adjustment before we record the brightness.
   base::TimeDelta brightness_sample_delay_;
@@ -104,7 +101,7 @@ class BrightnessMonitorImpl : public BrightnessMonitor,
 
   base::ObserverList<BrightnessMonitor::Observer> observers_;
 
-  base::WeakPtrFactory<BrightnessMonitorImpl> weak_ptr_factory_;
+  base::WeakPtrFactory<BrightnessMonitorImpl> weak_ptr_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(BrightnessMonitorImpl);
 };

chrome/browser/chromeos/power/auto_screen_brightness/brightness_monitor_impl_unittest.cc

@@ -101,8 +101,7 @@ class BrightnessMonitorImplTest : public testing::Test {
           features::kAutoScreenBrightness, params);
     }
 
-    monitor_ =
-        std::make_unique<BrightnessMonitorImpl>(PowerManagerClient::Get());
+    monitor_ = std::make_unique<BrightnessMonitorImpl>();
     test_observer_ = std::make_unique<TestObserver>();
     monitor_->AddObserver(test_observer_.get());
     scoped_task_environment_.RunUntilIdle();

chrome/browser/chromeos/power/auto_screen_brightness/controller.cc

@@ -33,8 +33,7 @@ Controller::Controller() {
   als_reader_ = std::make_unique<AlsReaderImpl>();
   als_reader_->Init();
 
-  brightness_monitor_ =
-      std::make_unique<BrightnessMonitorImpl>(power_manager_client);
+  brightness_monitor_ = std::make_unique<BrightnessMonitorImpl>();
 
   model_config_loader_ = std::make_unique<ModelConfigLoaderImpl>();
 

chromeos/constants/chromeos_features.cc

@@ -52,6 +52,12 @@ const base::Feature kEnableFileManagerFeedbackPanel{
 const base::Feature kEnableMessagesWebPush{"EnableMessagesWebPush",
                                            base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Enables the use of Mojo by Chrome-process code to communicate with Power
+// Manager. In order to use mojo, this feature must be turned on and a callsite
+// must use PowerManagerMojoClient::Get().
+const base::Feature kMojoDBusRelay{"MojoDBusRelay",
+                                   base::FEATURE_DISABLED_BY_DEFAULT};
+
 // If enabled, MyFiles will be a root/volume and user can create other
 // sub-folders and files in addition to the Downloads folder inside MyFiles.
 const base::Feature kMyFilesVolume{"MyFilesVolume",

chromeos/constants/chromeos_features.h

@@ -34,6 +34,7 @@ COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const base::Feature kEnableFileManagerFeedbackPanel;
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const base::Feature kEnableMessagesWebPush;
+COMPONENT_EXPORT(CHROMEOS_CONSTANTS) extern const base::Feature kMojoDBusRelay;
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) extern const base::Feature kMyFilesVolume;
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const base::Feature kEnableSupervisionTransitionScreens;

chromeos/dbus/power/power_manager_client.cc

@@ -209,7 +209,7 @@ class PowerManagerClientImpl : public PowerManagerClient {
   // PowerManagerClient overrides:
 
   void AddObserver(Observer* observer) override {
-    CHECK(observer);  // http://crbug.com/119976
+    DCHECK(observer);  // http://crbug.com/119976
     observers_.AddObserver(observer);
   }
 
@@ -1043,7 +1043,7 @@ class PowerManagerClientImpl : public PowerManagerClient {
   // Reports suspend readiness to powerd if no observers are still holding
   // suspend readiness callbacks.
   void MaybeReportSuspendReadiness() {
-    CHECK(suspend_is_pending_);
+    DCHECK(suspend_is_pending_);
 
     // Avoid reporting suspend readiness if some observers have yet to be
     // notified about the pending attempt.
@@ -1143,31 +1143,34 @@ class PowerManagerClientImpl : public PowerManagerClient {
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
-PowerManagerClient::PowerManagerClient() {
-  CHECK(!g_instance);
-  g_instance = this;
-}
-
-PowerManagerClient::~PowerManagerClient() {
-  CHECK_EQ(this, g_instance);
-  g_instance = nullptr;
-}
+// Unlike most D-Bus clients, PowerManagerClient doesn't set the singleton
+// instance in the ctor. This is because the mojo client is also a
+// PowerManagerClient, and co-exists with the D-Bus client in single process
+// Mash. When multi-process Mash is default, g_instance setting/clearing can be
+// moved back to the ctor/dtor.
+PowerManagerClient::PowerManagerClient() = default;
+PowerManagerClient::~PowerManagerClient() = default;
 
 // static
 void PowerManagerClient::Initialize(dbus::Bus* bus) {
-  CHECK(bus);
-  (new PowerManagerClientImpl())->Init(bus);
+  DCHECK(bus);
+  DCHECK(!g_instance);
+  auto* power_manager_client = new PowerManagerClientImpl();
+  power_manager_client->Init(bus);
+  g_instance = power_manager_client;
 }
 
 // static
 void PowerManagerClient::InitializeFake() {
-  new FakePowerManagerClient();
+  DCHECK(!g_instance);
+  g_instance = new FakePowerManagerClient();
 }
 
 // static
 void PowerManagerClient::Shutdown() {
-  CHECK(g_instance);
+  DCHECK(g_instance);
   delete g_instance;
+  g_instance = nullptr;
 }
 
 // static

chromeos/disks/suspend_unmount_manager_unittest.cc

@@ -49,14 +49,23 @@ class FakeDiskMountManager : public MockDiskMountManager {
 
 class SuspendUnmountManagerTest : public testing::Test {
  public:
-  SuspendUnmountManagerTest()
-      : suspend_unmount_manager_(&disk_mount_manager_) {}
-  ~SuspendUnmountManagerTest() override = default;
+  SuspendUnmountManagerTest() {
+    PowerManagerClient::InitializeFake();
+    suspend_unmount_manager_ =
+        std::make_unique<SuspendUnmountManager>(&disk_mount_manager_);
+  }
+
+  ~SuspendUnmountManagerTest() override {
+    suspend_unmount_manager_.reset();
+    PowerManagerClient::Shutdown();
+  }
 
  protected:
   FakeDiskMountManager disk_mount_manager_;
-  FakePowerManagerClient fake_power_client_;
-  SuspendUnmountManager suspend_unmount_manager_;
+  std::unique_ptr<SuspendUnmountManager> suspend_unmount_manager_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SuspendUnmountManagerTest);
 };
 
 TEST_F(SuspendUnmountManagerTest, Basic) {
@@ -88,10 +97,12 @@ TEST_F(SuspendUnmountManagerTest, Basic) {
       false /* on_boot_device */, true /* on_removable_device */,
       kFileSystemType);
   disk_mount_manager_.SetupDefaultReplies();
-  fake_power_client_.SendSuspendImminent(
+  FakePowerManagerClient::Get()->SendSuspendImminent(
       power_manager::SuspendImminent_Reason_OTHER);
 
-  EXPECT_EQ(1, fake_power_client_.num_pending_suspend_readiness_callbacks());
+  EXPECT_EQ(
+      1,
+      FakePowerManagerClient::Get()->num_pending_suspend_readiness_callbacks());
   EXPECT_EQ(2u, disk_mount_manager_.unmounting_mount_paths().size());
   EXPECT_EQ(1, std::count(disk_mount_manager_.unmounting_mount_paths().begin(),
                           disk_mount_manager_.unmounting_mount_paths().end(),
@@ -103,7 +114,9 @@ TEST_F(SuspendUnmountManagerTest, Basic) {
                           disk_mount_manager_.unmounting_mount_paths().end(),
                           kDummyMountPathUnknown));
   disk_mount_manager_.NotifyUnmountDeviceComplete(MOUNT_ERROR_NONE);
-  EXPECT_EQ(0, fake_power_client_.num_pending_suspend_readiness_callbacks());
+  EXPECT_EQ(
+      0,
+      FakePowerManagerClient::Get()->num_pending_suspend_readiness_callbacks());
 }
 
 TEST_F(SuspendUnmountManagerTest, CancelAndSuspendAgain) {
@@ -117,18 +130,20 @@ TEST_F(SuspendUnmountManagerTest, CancelAndSuspendAgain) {
       false /* on_boot_device */, true /* on_removable_device */,
       kFileSystemType);
   disk_mount_manager_.SetupDefaultReplies();
-  fake_power_client_.SendSuspendImminent(
+  FakePowerManagerClient::Get()->SendSuspendImminent(
       power_manager::SuspendImminent_Reason_OTHER);
-  EXPECT_EQ(1, fake_power_client_.num_pending_suspend_readiness_callbacks());
+  EXPECT_EQ(
+      1,
+      FakePowerManagerClient::Get()->num_pending_suspend_readiness_callbacks());
   ASSERT_EQ(1u, disk_mount_manager_.unmounting_mount_paths().size());
   EXPECT_EQ(kDummyMountPath,
             disk_mount_manager_.unmounting_mount_paths().front());
 
   // Suspend cancelled.
-  fake_power_client_.SendSuspendDone();
+  FakePowerManagerClient::Get()->SendSuspendDone();
 
   // Suspend again.
-  fake_power_client_.SendSuspendImminent(
+  FakePowerManagerClient::Get()->SendSuspendImminent(
       power_manager::SuspendImminent_Reason_OTHER);
   ASSERT_EQ(2u, disk_mount_manager_.unmounting_mount_paths().size());
   EXPECT_EQ(kDummyMountPath,

chromeos/services/power/public/cpp/BUILD.gn

+# Copyright 2019 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.
+
+assert(is_chromeos, "Non-Chrome-OS builds must not depend on //chromeos")
+
+# This code is the Mojo controller, so it lives in the same process as the D-Bus
+# client.
+component("controller") {
+  output_name = "chromeos_power_mojo_controller"
+  defines = [ "IS_CHROMEOS_POWER_MOJO_CONTROLLER_IMPL" ]
+
+  deps = [
+    "//base",
+    "//chromeos/dbus/power",
+    "//chromeos/dbus/power:power_manager_proto",
+    "//chromeos/services/power/public/mojom",
+  ]
+  sources = [
+    "power_manager_mojo_controller.cc",
+    "power_manager_mojo_controller.h",
+  ]
+}
+
+# The client may live in a separate process (such as Chrome in multi-process
+# Mash).
+component("client") {
+  output_name = "chromeos_power_mojo_client"
+  defines = [ "IS_CHROMEOS_POWER_MOJO_CLIENT_IMPL" ]
+
+  deps = [
+    "//base",
+    "//chromeos/constants",
+    "//chromeos/dbus/power",
+    "//chromeos/dbus/power:power_manager_proto",
+    "//chromeos/services/power/public/mojom",
+  ]
+  sources = [
+    "power_manager_mojo_client.cc",
+    "power_manager_mojo_client.h",
+  ]
+}

chromeos/services/power/public/cpp/power_manager_mojo_client.cc

+// Copyright 2019 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/services/power/public/cpp/power_manager_mojo_client.h"
+
+#include "base/feature_list.h"
+#include "chromeos/constants/chromeos_features.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
+
+namespace chromeos {
+
+namespace {
+PowerManagerMojoClient* g_instance = nullptr;
+}  // namespace
+
+PowerManagerMojoClient::PowerManagerMojoClient() {
+  DCHECK(base::FeatureList::IsEnabled(chromeos::features::kMojoDBusRelay));
+  DCHECK(!g_instance);
+  g_instance = this;
+}
+
+PowerManagerMojoClient::~PowerManagerMojoClient() {
+  DCHECK_EQ(g_instance, this);
+  g_instance = nullptr;
+}
+
+void PowerManagerMojoClient::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void PowerManagerMojoClient::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool PowerManagerMojoClient::HasObserver(const Observer* observer) const {
+  return observers_.HasObserver(observer);
+}
+
+void PowerManagerMojoClient::WaitForServiceToBeAvailable(
+    WaitForServiceToBeAvailableCallback callback) {}
+
+void PowerManagerMojoClient::SetRenderProcessManagerDelegate(
+    base::WeakPtr<RenderProcessManagerDelegate> delegate) {}
+
+void PowerManagerMojoClient::DecreaseScreenBrightness(bool allow_off) {}
+
+void PowerManagerMojoClient::IncreaseScreenBrightness() {}
+
+void PowerManagerMojoClient::SetScreenBrightness(
+    const power_manager::SetBacklightBrightnessRequest& request) {}
+
+void PowerManagerMojoClient::GetScreenBrightnessPercent(
+    DBusMethodCallback<double> callback) {
+  // This extra thunk is only necessary to convert between
+  // power::mojom::BrightnessPtr and base::Optional<double>.
+  controller_->GetScreenBrightnessPercent(base::BindOnce(
+      [](DBusMethodCallback<double> callback,
+         power::mojom::BrightnessPtr brightness) {
+        if (brightness)
+          std::move(callback).Run(brightness->value);
+        else
+          std::move(callback).Run(base::nullopt);
+      },
+      std::move(callback)));
+}
+
+void PowerManagerMojoClient::DecreaseKeyboardBrightness() {}
+
+void PowerManagerMojoClient::IncreaseKeyboardBrightness() {}
+
+void PowerManagerMojoClient::GetKeyboardBrightnessPercent(
+    DBusMethodCallback<double> callback) {}
+
+const base::Optional<power_manager::PowerSupplyProperties>&
+PowerManagerMojoClient::GetLastStatus() {
+  return proto_;
+}
+
+void PowerManagerMojoClient::RequestStatusUpdate() {}
+
+void PowerManagerMojoClient::RequestSuspend() {}
+
+void PowerManagerMojoClient::RequestRestart(
+    power_manager::RequestRestartReason reason,
+    const std::string& description) {}
+
+void PowerManagerMojoClient::RequestShutdown(
+    power_manager::RequestShutdownReason reason,
+    const std::string& description) {}
+
+void PowerManagerMojoClient::NotifyUserActivity(
+    power_manager::UserActivityType type) {}
+
+void PowerManagerMojoClient::NotifyVideoActivity(bool is_fullscreen) {}
+
+void PowerManagerMojoClient::NotifyWakeNotification() {}
+
+void PowerManagerMojoClient::SetPolicy(
+    const power_manager::PowerManagementPolicy& policy) {}
+
+void PowerManagerMojoClient::SetIsProjecting(bool is_projecting) {}
+
+void PowerManagerMojoClient::SetPowerSource(const std::string& id) {}
+
+void PowerManagerMojoClient::SetBacklightsForcedOff(bool forced_off) {}
+
+void PowerManagerMojoClient::GetBacklightsForcedOff(
+    DBusMethodCallback<bool> callback) {}
+
+void PowerManagerMojoClient::GetSwitchStates(
+    DBusMethodCallback<SwitchStates> callback) {}
+
+void PowerManagerMojoClient::GetInactivityDelays(
+    DBusMethodCallback<power_manager::PowerManagementPolicy::Delays> callback) {
+}
+
+base::OnceClosure PowerManagerMojoClient::GetSuspendReadinessCallback(
+    const base::Location& from_where) {
+  return base::OnceClosure();
+}
+
+void PowerManagerMojoClient::CreateArcTimers(
+    const std::string& tag,
+    std::vector<std::pair<clockid_t, base::ScopedFD>> arc_timer_requests,
+    DBusMethodCallback<std::vector<TimerId>> callback) {}
+
+void PowerManagerMojoClient::StartArcTimer(
+    TimerId timer_id,
+    base::TimeTicks absolute_expiration_time,
+    VoidDBusMethodCallback callback) {}
+
+void PowerManagerMojoClient::DeleteArcTimers(const std::string& tag,
+                                             VoidDBusMethodCallback callback) {}
+
+void PowerManagerMojoClient::DeferScreenDim() {}
+
+void PowerManagerMojoClient::ScreenBrightnessChanged(double percent) {
+  power_manager::BacklightBrightnessChange change;
+  change.set_percent(percent);
+  for (auto& observer : observers_)
+    observer.ScreenBrightnessChanged(change);
+}
+
+void PowerManagerMojoClient::InitAfterInterfaceBound() {
+  DCHECK(controller_.is_bound());
+  power::mojom::PowerManagerObserverAssociatedPtrInfo ptr_info;
+  binding_.Bind(mojo::MakeRequest(&ptr_info));
+  controller_->SetObserver(std::move(ptr_info));
+}
+
+// static
+PowerManagerClient* PowerManagerMojoClient::Get() {
+  DCHECK_EQ(base::FeatureList::IsEnabled(chromeos::features::kMojoDBusRelay),
+            !!g_instance);
+  return g_instance ? g_instance : ::chromeos::PowerManagerClient::Get();
+}
+
+}  // namespace chromeos

chromeos/services/power/public/cpp/power_manager_mojo_client.h

+// Copyright 2019 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_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CLIENT_H_
+#define CHROMEOS_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CLIENT_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chromeos/dbus/power/power_manager_client.h"
+#include "chromeos/services/power/public/mojom/power_manager.mojom.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+
+namespace chromeos {
+
+// PowerManagerMojoClient implements the PowerManagerClient interface (which is
+// shared with the D-Bus implementation) and forwards calls over mojo to
+// PowerManagerMojoController.
+class COMPONENT_EXPORT(CHROMEOS_POWER_MOJO_CLIENT) PowerManagerMojoClient
+    : public PowerManagerClient,
+      public power::mojom::PowerManagerObserver {
+ public:
+  PowerManagerMojoClient();
+  ~PowerManagerMojoClient() override;
+
+  // PowerManagerClient:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  bool HasObserver(const Observer* observer) const override;
+  void WaitForServiceToBeAvailable(
+      WaitForServiceToBeAvailableCallback callback) override;
+  void SetRenderProcessManagerDelegate(
+      base::WeakPtr<RenderProcessManagerDelegate> delegate) override;
+  void DecreaseScreenBrightness(bool allow_off) override;
+  void IncreaseScreenBrightness() override;
+  void SetScreenBrightness(
+      const power_manager::SetBacklightBrightnessRequest& request) override;
+  void GetScreenBrightnessPercent(DBusMethodCallback<double> callback) override;
+  void DecreaseKeyboardBrightness() override;
+  void IncreaseKeyboardBrightness() override;
+  void GetKeyboardBrightnessPercent(
+      DBusMethodCallback<double> callback) override;
+  const base::Optional<power_manager::PowerSupplyProperties>& GetLastStatus()
+      override;
+  void RequestStatusUpdate() override;
+  void RequestSuspend() override;
+  void RequestRestart(power_manager::RequestRestartReason reason,
+                      const std::string& description) override;
+  void RequestShutdown(power_manager::RequestShutdownReason reason,
+                       const std::string& description) override;
+  void NotifyUserActivity(power_manager::UserActivityType type) override;
+  void NotifyVideoActivity(bool is_fullscreen) override;
+  void NotifyWakeNotification() override;
+  void SetPolicy(const power_manager::PowerManagementPolicy& policy) override;
+  void SetIsProjecting(bool is_projecting) override;
+  void SetPowerSource(const std::string& id) override;
+  void SetBacklightsForcedOff(bool forced_off) override;
+  void GetBacklightsForcedOff(DBusMethodCallback<bool> callback) override;
+  void GetSwitchStates(DBusMethodCallback<SwitchStates> callback) override;
+  void GetInactivityDelays(
+      DBusMethodCallback<power_manager::PowerManagementPolicy::Delays> callback)
+      override;
+  base::OnceClosure GetSuspendReadinessCallback(
+      const base::Location& from_where) override;
+  void CreateArcTimers(
+      const std::string& tag,
+      std::vector<std::pair<clockid_t, base::ScopedFD>> arc_timer_requests,
+      DBusMethodCallback<std::vector<TimerId>> callback) override;
+  void StartArcTimer(TimerId timer_id,
+                     base::TimeTicks absolute_expiration_time,
+                     VoidDBusMethodCallback callback) override;
+  void DeleteArcTimers(const std::string& tag,
+                       VoidDBusMethodCallback callback) override;
+  void DeferScreenDim() override;
+
+  // power::mojom::PowerManagerObserver:
+  void ScreenBrightnessChanged(double percent) override;
+
+  power::mojom::PowerManagerControllerPtr* interface_ptr() {
+    return &controller_;
+  }
+
+  // Init done after |controller_| is bound.
+  void InitAfterInterfaceBound();
+
+  // Returns the chromeos::PowerManagerClient implementation, which may either
+  // be backed by D-Bus or a fake (if mojo is not enabled), or a
+  // PowerManagerMojoClient. This only exists for the sake of SingleProcessMash,
+  // where a PowerManagerMojoClient and a PowerManagerClientImpl may coexist in
+  // the same process. Otherwise, PowerManagerClient::Get would be enough.
+  static ::chromeos::PowerManagerClient* Get();
+
+ private:
+  power::mojom::PowerManagerControllerPtr controller_;
+  mojo::AssociatedBinding<power::mojom::PowerManagerObserver> binding_{this};
+
+  base::ObserverList<Observer>::Unchecked observers_;
+
+  // The last proto received via mojo; initially empty.
+  base::Optional<power_manager::PowerSupplyProperties> proto_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerManagerMojoClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CLIENT_H_

chromeos/services/power/public/cpp/power_manager_mojo_controller.cc

+// Copyright 2019 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/services/power/public/cpp/power_manager_mojo_controller.h"
+
+#include "chromeos/dbus/power_manager/backlight.pb.h"
+
+namespace chromeos {
+
+PowerManagerMojoController::PowerManagerMojoController() = default;
+
+PowerManagerMojoController::~PowerManagerMojoController() {
+  if (PowerManagerClient::Get()->HasObserver(this))
+    PowerManagerClient::Get()->RemoveObserver(this);
+}
+
+void PowerManagerMojoController::BindRequest(
+    power::mojom::PowerManagerControllerRequest request) {
+  binding_set_.AddBinding(this, std::move(request));
+}
+
+void PowerManagerMojoController::SetObserver(
+    power::mojom::PowerManagerObserverAssociatedPtrInfo client) {
+  DCHECK(!client_.is_bound());
+  client_.Bind(std::move(client));
+
+  PowerManagerClient::Get()->AddObserver(this);
+}
+
+void PowerManagerMojoController::GetScreenBrightnessPercent(
+    GetScreenBrightnessPercentCallback callback) {
+  // This extra thunk is only necessary to convert between
+  // power::mojom::BrightnessPtr and base::Optional<double>.
+  PowerManagerClient::Get()->GetScreenBrightnessPercent(base::BindOnce(
+      [](GetScreenBrightnessPercentCallback callback,
+         base::Optional<double> value) {
+        if (value)
+          std::move(callback).Run(power::mojom::Brightness::New(*value));
+        else
+          std::move(callback).Run({});
+      },
+      std::move(callback)));
+}
+
+void PowerManagerMojoController::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
+  // TODO(estade): serialize and pass all of |change|.
+  client_->ScreenBrightnessChanged(change.percent());
+}
+
+}  // namespace chromeos

chromeos/services/power/public/cpp/power_manager_mojo_controller.h

+// Copyright 2019 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_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CONTROLLER_H_
+#define CHROMEOS_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CONTROLLER_H_
+
+#include "base/macros.h"
+#include "chromeos/dbus/power/power_manager_client.h"
+#include "chromeos/services/power/public/mojom/power_manager.mojom.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+
+namespace chromeos {
+
+// PowerManagerMojoController simply passes incoming mojo messages through to
+// the D-Bus-backed (or fake) PowerManagerClient. It informs |client_| of
+// changes by passing along PowerManagerClient::Observer notifications.
+class COMPONENT_EXPORT(CHROMEOS_POWER_MOJO_CONTROLLER)
+    PowerManagerMojoController : public power::mojom::PowerManagerController,
+                                 public PowerManagerClient::Observer {
+ public:
+  PowerManagerMojoController();
+  ~PowerManagerMojoController() override;
+
+  void BindRequest(power::mojom::PowerManagerControllerRequest request);
+
+  // mojom::PowerManagerMojoController:
+  void SetObserver(
+      power::mojom::PowerManagerObserverAssociatedPtrInfo client) override;
+  void GetScreenBrightnessPercent(
+      GetScreenBrightnessPercentCallback callback) override;
+
+  // PowerManagerClient::Observer:
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
+
+ private:
+  mojo::BindingSet<power::mojom::PowerManagerController> binding_set_;
+  power::mojom::PowerManagerObserverAssociatedPtr client_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerManagerMojoController);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_POWER_PUBLIC_CPP_POWER_MANAGER_MOJO_CONTROLLER_H_

chromeos/services/power/public/mojom/BUILD.gn

+# Copyright 2019 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.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+mojom("mojom") {
+  disable_variants = true
+
+  sources = [
+    "power_manager.mojom",
+  ]
+
+  public_deps = [
+    "//mojo/public/mojom/base",
+    "//services/content/public/mojom",
+    "//services/preferences/public/mojom",
+    "//ui/base/mojo",
+  ]
+
+  component_macro_prefix = "CHROMEOS_POWER_MOJO"
+  component_output_prefix = "chromeos_power_mojo_mojom"
+}

chromeos/services/power/public/mojom/OWNERS

+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS

chromeos/services/power/public/mojom/power_manager.mojom

+// Copyright 2019 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.
+
+module chromeos.power.mojom;
+
+// TODO(https://crbug.com/657632): This struct wrapper exists to allow the value
+// to be null.
+struct Brightness {
+  double value;
+};
+
+// The interface for handling out-of-process calls that query or adjust power
+// related state. The implementation relays calls to the D-Bus client, which
+// uses D-Bus to communicate with the Power Manager daemon. In Mash, this lives
+// in the Ash process.
+interface PowerManagerController {
+  SetObserver(associated PowerManagerObserver observer);
+
+  // All following methods and their semantics are copied from the
+  // PowerManagerClient interface. Refer to that for documentation.
+  GetScreenBrightnessPercent() => (Brightness? brightness);
+};
+
+// An interface for observing changes to power state. The changes are dispatched
+// over mojo from PowerManagerController.
+interface PowerManagerObserver {
+  // TODO(estade): the parameter should be a BacklightBrightnessChange.
+  ScreenBrightnessChanged(double percent);
+};