chromeos: Update for ScreenBrightnessChanged D-Bus signal.

Update PowerManagerClient to listen for the new
ScreenBrightnessChanged D-Bus signal emitted by powerd,
which contains a protobuf and replaces the earlier
BrightnessChanged signal.

Also update Chrome to decode protobufs from
KeyboardBrightnessChanged signals.

Bug: 811138
Change-Id: If313801aa516850d904540736a2dee63bac7d6e7
Reviewed-on: https://chromium-review.googlesource.com/952578
Commit-Queue: Dan Erat <derat@chromium.org>
Reviewed-by: Luis Hector Chavez <lhchavez@chromium.org>
Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#542160}

ash/lock_screen_action/lock_screen_note_display_state_handler_unittest.cc

@@ -24,6 +24,7 @@
 #include "base/test/simple_test_tick_clock.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "services/ui/public/cpp/input_devices/input_device_client_test_api.h"
 #include "ui/events/devices/stylus_state.h"
 
@@ -46,15 +47,16 @@ class TestPowerManagerObserver : public chromeos::PowerManagerClient::Observer {
     power_manager_->set_user_activity_callback(base::RepeatingClosure());
   }
 
-  const std::vector<int> brightness_changes() const {
+  const std::vector<double>& brightness_changes() const {
     return brightness_changes_;
   }
 
   void ClearBrightnessChanges() { brightness_changes_.clear(); }
 
   // chromeos::PowerManagerClient::Observer:
-  void BrightnessChanged(int level, bool user_initiated) override {
-    brightness_changes_.push_back(level);
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override {
+    brightness_changes_.push_back(change.percent());
   }
 
   void OnUserActivity() {
@@ -66,7 +68,7 @@ class TestPowerManagerObserver : public chromeos::PowerManagerClient::Observer {
 
  private:
   chromeos::FakePowerManagerClient* power_manager_;
-  std::vector<int> brightness_changes_;
+  std::vector<double> brightness_changes_;
 
   ScopedObserver<chromeos::PowerManagerClient,
                  chromeos::PowerManagerClient::Observer>
@@ -145,7 +147,10 @@ class LockScreenNoteDisplayStateHandlerTest : public AshTestBase {
 
   void TurnScreenOffForUserInactivity() {
     power_manager_client_->set_screen_brightness_percent(0);
-    power_manager_client_->SendBrightnessChanged(0, false /*user_initiated*/);
+    power_manager::BacklightBrightnessChange change;
+    change.set_percent(0.0);
+    change.set_cause(power_manager::BacklightBrightnessChange_Cause_OTHER);
+    power_manager_client_->SendScreenBrightnessChanged(change);
     power_manager_observer_->ClearBrightnessChanges();
   }
 
@@ -227,7 +232,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, EjectWhenScreenOff) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({0}),
+  EXPECT_EQ(std::vector<double>({0.0}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -239,7 +244,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, EjectWhenScreenOff) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
 
   ASSERT_FALSE(LaunchTimeoutRunning());
@@ -261,7 +266,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest,
 
   // Styluls eject is expected to turn the screen on due to user activity.
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -289,7 +294,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, TurnScreenOnWhenAppLaunchFails) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({0}),
+  EXPECT_EQ(std::vector<double>({0.0}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -301,7 +306,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, TurnScreenOnWhenAppLaunchFails) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
 
   ASSERT_FALSE(LaunchTimeoutRunning());
@@ -316,7 +321,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, EjectWhileScreenForcedOff) {
   SimulatePowerButtonPress();
 
   ASSERT_TRUE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({0}),
+  EXPECT_EQ(std::vector<double>({0.0}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -335,7 +340,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, EjectWhileScreenForcedOff) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
 
   ASSERT_FALSE(LaunchTimeoutRunning());
@@ -352,7 +357,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, DisplayNotTurnedOffIndefinitely) {
       mojom::LockScreenNoteOrigin::kStylusEject));
 
   EXPECT_TRUE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({0}),
+  EXPECT_EQ(std::vector<double>({0.0}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -360,7 +365,7 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest, DisplayNotTurnedOffIndefinitely) {
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -384,7 +389,8 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest,
   SimulatePowerButtonPress();
   EXPECT_TRUE(power_manager_client_->backlights_forced_off());
   EXPECT_TRUE(power_manager_observer_->brightness_changes().empty());
-  EXPECT_EQ(1u, power_manager_client_->pending_brightness_changes().size());
+  EXPECT_EQ(1u,
+            power_manager_client_->pending_screen_brightness_changes().size());
 
   ui::InputDeviceClientTestApi devices_test_api;
   devices_test_api.NotifyObserversStylusStateChanged(ui::StylusState::REMOVED);
@@ -396,12 +402,14 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest,
   EXPECT_TRUE(tray_action_client_.note_origins().empty());
 
   // Apply screen brightness set by forcing backlights off,
-  EXPECT_EQ(1u, power_manager_client_->pending_brightness_changes().size());
-  ASSERT_TRUE(power_manager_client_->ApplyPendingBrightnessChange());
+  EXPECT_EQ(1u,
+            power_manager_client_->pending_screen_brightness_changes().size());
+  ASSERT_TRUE(power_manager_client_->ApplyPendingScreenBrightnessChange());
 
   EXPECT_TRUE(power_manager_client_->backlights_forced_off());
-  EXPECT_TRUE(power_manager_client_->pending_brightness_changes().empty());
-  EXPECT_EQ(std::vector<int>({0}),
+  EXPECT_TRUE(
+      power_manager_client_->pending_screen_brightness_changes().empty());
+  EXPECT_EQ(std::vector<double>({0.0}),
             power_manager_observer_->brightness_changes());
   power_manager_observer_->ClearBrightnessChanges();
 
@@ -412,8 +420,8 @@ TEST_F(LockScreenNoteDisplayStateHandlerTest,
       mojom::TrayActionState::kActive);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(power_manager_client_->backlights_forced_off());
-  ASSERT_TRUE(power_manager_client_->ApplyPendingBrightnessChange());
-  EXPECT_EQ(std::vector<int>({kVisibleBrightnessPercent}),
+  ASSERT_TRUE(power_manager_client_->ApplyPendingScreenBrightnessChange());
+  EXPECT_EQ(std::vector<double>({kVisibleBrightnessPercent}),
             power_manager_observer_->brightness_changes());
 
   ASSERT_FALSE(LaunchTimeoutRunning());

ash/system/brightness/tray_brightness.cc

@@ -20,6 +20,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
@@ -239,11 +240,14 @@ bool TrayBrightness::ShouldShowShelf() const {
   return false;
 }
 
-void TrayBrightness::BrightnessChanged(int level, bool user_initiated) {
+void TrayBrightness::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
   Shell::Get()->metrics()->RecordUserMetricsAction(
       UMA_STATUS_AREA_BRIGHTNESS_CHANGED);
-  double percent = static_cast<double>(level);
-  HandleBrightnessChanged(percent, user_initiated);
+  const bool user_initiated =
+      change.cause() ==
+      power_manager::BacklightBrightnessChange_Cause_USER_REQUEST;
+  HandleBrightnessChanged(change.percent(), user_initiated);
 }
 
 void TrayBrightness::HandleBrightnessChanged(double percent,

ash/system/brightness/tray_brightness.h

@@ -44,7 +44,8 @@ class ASH_EXPORT TrayBrightness
   bool ShouldShowShelf() const override;
 
   // Overriden from PowerManagerClient::Observer.
-  void BrightnessChanged(int level, bool user_initiated) override;
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
 
   void HandleBrightnessChanged(double percent, bool user_initiated);
 

ash/system/keyboard_brightness/tray_keyboard_brightness.cc

@@ -19,6 +19,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
@@ -146,14 +147,15 @@ bool TrayKeyboardBrightness::ShouldShowShelf() const {
   return false;
 }
 
-void TrayKeyboardBrightness::KeyboardBrightnessChanged(int level,
-                                                       bool user_initiated) {
-  current_percent_ = static_cast<double>(level);
+void TrayKeyboardBrightness::KeyboardBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
+  current_percent_ = change.percent();
 
   if (brightness_view_)
     brightness_view_->SetKeyboardBrightnessPercent(current_percent_);
 
-  if (!user_initiated)
+  if (change.cause() !=
+      power_manager::BacklightBrightnessChange_Cause_USER_REQUEST)
     return;
 
   if (brightness_view_ && brightness_view_->visible())

ash/system/keyboard_brightness/tray_keyboard_brightness.h

@@ -34,7 +34,8 @@ class ASH_EXPORT TrayKeyboardBrightness
   bool ShouldShowShelf() const override;
 
   // Overriden from PowerManagerClient::Observer.
-  void KeyboardBrightnessChanged(int level, bool user_initiated) override;
+  void KeyboardBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
 
   tray::KeyboardBrightnessView* brightness_view_ = nullptr;
 

ash/system/power/backlights_forced_off_setter.cc

@@ -12,6 +12,7 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 
 namespace ash {
 
@@ -51,10 +52,14 @@ BacklightsForcedOffSetter::ForceBacklightsOff() {
   return scoped_backlights_forced_off;
 }
 
-void BacklightsForcedOffSetter::BrightnessChanged(int level,
-                                                  bool user_initiated) {
+void BacklightsForcedOffSetter::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
+  const bool user_initiated =
+      change.cause() ==
+      power_manager::BacklightBrightnessChange_Cause_USER_REQUEST;
+
   const ScreenState old_state = screen_state_;
-  if (level != 0)
+  if (change.percent() > 0.0)
     screen_state_ = ScreenState::ON;
   else
     screen_state_ = user_initiated ? ScreenState::OFF : ScreenState::OFF_AUTO;

ash/system/power/backlights_forced_off_setter.h

@@ -65,7 +65,8 @@ class ASH_EXPORT BacklightsForcedOffSetter
   std::unique_ptr<ScopedBacklightsForcedOff> ForceBacklightsOff();
 
   // Overridden from chromeos::PowerManagerClient::Observer:
-  void BrightnessChanged(int level, bool user_initiated) override;
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
   void PowerManagerRestarted() override;
 
   // Resets internal state for tests.

ash/system/power/power_button_controller.cc

@@ -4,6 +4,7 @@
 
 #include "ash/system/power/power_button_controller.h"
 
+#include <limits>
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
@@ -22,6 +23,7 @@
 #include "base/command_line.h"
 #include "base/time/default_tick_clock.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/views/widget/widget.h"
 
@@ -239,8 +241,10 @@ void PowerButtonController::OnDisplayModeChanged(
       internal_display_off && external_display_on;
 }
 
-void PowerButtonController::BrightnessChanged(int level, bool user_initiated) {
-  brightness_is_zero_ = level == 0;
+void PowerButtonController::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
+  brightness_is_zero_ =
+      change.percent() <= std::numeric_limits<double>::epsilon();
 }
 
 void PowerButtonController::PowerButtonEventReceived(

ash/system/power/power_button_controller.h

@@ -98,7 +98,8 @@ class ASH_EXPORT PowerButtonController
       const display::DisplayConfigurator::DisplayStateList& outputs) override;
 
   // chromeos::PowerManagerClient::Observer:
-  void BrightnessChanged(int level, bool user_initiated) override;
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
   void PowerButtonEventReceived(bool down,
                                 const base::TimeTicks& timestamp) override;
   void SuspendImminent(power_manager::SuspendImminent::Reason reason) override;

ash/wm/lock_state_controller_unittest.cc

@@ -32,6 +32,11 @@
 namespace ash {
 namespace {
 
+// Shorthand for some long constants.
+constexpr power_manager::BacklightBrightnessChange_Cause kUserCause =
+    power_manager::BacklightBrightnessChange_Cause_USER_REQUEST;
+constexpr power_manager::BacklightBrightnessChange_Cause kOtherCause =
+    power_manager::BacklightBrightnessChange_Cause_OTHER;
 bool cursor_visible() {
   return Shell::Get()->cursor_manager()->IsCursorVisible();
 }
@@ -91,6 +96,15 @@ class LockStateControllerTest : public PowerButtonTestBase {
     test_animator_->Advance(test_animator_->GetDuration(speed) * factor);
   }
 
+  void SendBrightnessChange(
+      double percent,
+      power_manager::BacklightBrightnessChange_Cause cause) {
+    power_manager::BacklightBrightnessChange change;
+    change.set_percent(percent);
+    change.set_cause(cause);
+    power_manager_client_->SendScreenBrightnessChanged(change);
+  }
+
   void ExpectPreLockAnimationStarted() {
     SCOPED_TRACE("Failure in ExpectPreLockAnimationStarted");
     EXPECT_LT(0u, test_animator_->GetAnimationCount());
@@ -342,14 +356,14 @@ TEST_F(LockStateControllerTest, LegacyIgnorePowerButtonIfScreenIsOff) {
 
   // When the screen brightness is at 0%, we shouldn't do anything in response
   // to power button presses.
-  power_manager_client_->SendBrightnessChanged(0, true);
+  SendBrightnessChange(0, kUserCause);
   PressPowerButton();
   EXPECT_FALSE(lock_state_test_api_->is_animating_lock());
   ReleasePowerButton();
 
   // After increasing the brightness to 10%, we should start the timer like
   // usual.
-  power_manager_client_->SendBrightnessChanged(10, true);
+  SendBrightnessChange(10, kUserCause);
   PressPowerButton();
   EXPECT_TRUE(lock_state_test_api_->is_animating_lock());
   ReleasePowerButton();
@@ -378,7 +392,7 @@ TEST_F(LockStateControllerTest, LegacyHonorPowerButtonInDockedMode) {
 
   // When all of the displays are turned off (e.g. due to user inactivity), the
   // power button should be ignored.
-  power_manager_client_->SendBrightnessChanged(0, true);
+  SendBrightnessChange(0, kUserCause);
   internal_display->set_current_mode(nullptr);
   external_display->set_current_mode(nullptr);
   power_button_controller_->OnDisplayModeChanged(outputs);
@@ -637,13 +651,13 @@ TEST_F(LockStateControllerTest, DisableTouchscreenForScreenOff) {
   base::RunLoop().RunUntilIdle();
 
   // Manually turn the screen off and check that the touchscreen is enabled.
-  power_manager_client_->SendBrightnessChanged(0, true /* user_initiated */);
+  SendBrightnessChange(0, kUserCause);
   EXPECT_TRUE(Shell::Get()->touch_devices_controller()->GetTouchscreenEnabled(
       TouchscreenEnabledSource::GLOBAL));
 
   // It should be disabled if the screen is turned off due to user inactivity.
-  power_manager_client_->SendBrightnessChanged(100, true /* user_initiated */);
-  power_manager_client_->SendBrightnessChanged(0, false /* user_initiated */);
+  SendBrightnessChange(100, kUserCause);
+  SendBrightnessChange(0, kOtherCause);
   EXPECT_FALSE(Shell::Get()->touch_devices_controller()->GetTouchscreenEnabled(
       TouchscreenEnabledSource::GLOBAL));
 }
@@ -660,7 +674,7 @@ TEST_F(LockStateControllerTest, TouchscreenUnableWhileScreenOff) {
   base::RunLoop().RunUntilIdle();
 
   // The touchscreen should remain enabled.
-  power_manager_client_->SendBrightnessChanged(0, false /* user_initiated */);
+  SendBrightnessChange(0, kOtherCause);
   EXPECT_TRUE(Shell::Get()->touch_devices_controller()->GetTouchscreenEnabled(
       TouchscreenEnabledSource::GLOBAL));
 }

chrome/browser/chromeos/extensions/extension_system_event_observer.cc

@@ -6,6 +6,7 @@
 
 #include "chrome/browser/extensions/api/system_private/system_private_api.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "components/session_manager/core/session_manager.h"
 
 namespace chromeos {
@@ -21,9 +22,12 @@ ExtensionSystemEventObserver::~ExtensionSystemEventObserver() {
   session_manager::SessionManager::Get()->RemoveObserver(this);
 }
 
-void ExtensionSystemEventObserver::BrightnessChanged(int level,
-                                                     bool user_initiated) {
-  extensions::DispatchBrightnessChangedEvent(level, user_initiated);
+void ExtensionSystemEventObserver::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
+  const bool user_initiated =
+      change.cause() ==
+      power_manager::BacklightBrightnessChange_Cause_USER_REQUEST;
+  extensions::DispatchBrightnessChangedEvent(change.percent(), user_initiated);
 }
 
 void ExtensionSystemEventObserver::SuspendDone(

chrome/browser/chromeos/extensions/extension_system_event_observer.h

@@ -22,7 +22,8 @@ class ExtensionSystemEventObserver
   ~ExtensionSystemEventObserver() override;
 
   // PowerManagerClient::Observer overrides:
-  void BrightnessChanged(int level, bool user_initiated) override;
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
   void SuspendDone(const base::TimeDelta& sleep_duration) override;
 
   // session_manager::SessionManagerObserver override:

chromeos/BUILD.gn

@@ -767,6 +767,7 @@ test("chromeos_unittests") {
 
 proto_library("power_manager_proto") {
   sources = [
+    "//third_party/cros_system_api/dbus/power_manager/backlight.proto",
     "//third_party/cros_system_api/dbus/power_manager/idle.proto",
     "//third_party/cros_system_api/dbus/power_manager/input_event.proto",
     "//third_party/cros_system_api/dbus/power_manager/peripheral_battery_status.proto",

chromeos/dbus/fake_power_manager_client.cc

@@ -61,9 +61,13 @@ void FakePowerManagerClient::SetScreenBrightnessPercent(double percent,
   screen_brightness_percent_ = percent;
   requested_screen_brightness_percent_ = percent;
 
+  power_manager::BacklightBrightnessChange change;
+  change.set_percent(percent);
+  change.set_cause(power_manager::BacklightBrightnessChange_Cause_USER_REQUEST);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(&FakePowerManagerClient::SendBrightnessChanged,
-                                weak_ptr_factory_.GetWeakPtr(), percent, true));
+      FROM_HERE,
+      base::BindOnce(&FakePowerManagerClient::SendScreenBrightnessChanged,
+                     weak_ptr_factory_.GetWeakPtr(), change));
 }
 
 void FakePowerManagerClient::GetScreenBrightnessPercent(
@@ -145,17 +149,21 @@ void FakePowerManagerClient::SetBacklightsForcedOff(bool forced_off) {
   backlights_forced_off_ = forced_off;
   ++num_set_backlights_forced_off_calls_;
 
-  double target_brightness =
-      forced_off ? 0 : requested_screen_brightness_percent_;
+  power_manager::BacklightBrightnessChange change;
+  change.set_percent(forced_off ? 0 : requested_screen_brightness_percent_);
+  change.set_cause(
+      forced_off ? power_manager::BacklightBrightnessChange_Cause_FORCED_OFF
+                 : power_manager::
+                       BacklightBrightnessChange_Cause_NO_LONGER_FORCED_OFF);
+
   if (enqueue_brightness_changes_on_backlights_forced_off_) {
-    pending_brightness_changes_.push(target_brightness);
+    pending_screen_brightness_changes_.push(change);
   } else {
-    screen_brightness_percent_ = target_brightness;
+    screen_brightness_percent_ = change.percent();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::BindOnce(&FakePowerManagerClient::SendBrightnessChanged,
-                       weak_ptr_factory_.GetWeakPtr(), target_brightness,
-                       false));
+        base::BindOnce(&FakePowerManagerClient::SendScreenBrightnessChanged,
+                       weak_ptr_factory_.GetWeakPtr(), change));
   }
 }
 
@@ -217,17 +225,16 @@ void FakePowerManagerClient::SendDarkSuspendImminent() {
     observer.DarkSuspendImminent();
 }
 
-void FakePowerManagerClient::SendBrightnessChanged(int level,
-                                                   bool user_initiated) {
+void FakePowerManagerClient::SendScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
   for (auto& observer : observers_)
-    observer.BrightnessChanged(level, user_initiated);
+    observer.ScreenBrightnessChanged(change);
 }
 
 void FakePowerManagerClient::SendKeyboardBrightnessChanged(
-    int level,
-    bool user_initiated) {
+    const power_manager::BacklightBrightnessChange& change) {
   for (auto& observer : observers_)
-    observer.KeyboardBrightnessChanged(level, user_initiated);
+    observer.KeyboardBrightnessChanged(change);
 }
 
 void FakePowerManagerClient::SendScreenIdleStateChanged(
@@ -286,16 +293,16 @@ void FakePowerManagerClient::SetPowerPolicyQuitClosure(
   power_policy_quit_closure_ = std::move(quit_closure);
 }
 
-bool FakePowerManagerClient::ApplyPendingBrightnessChange() {
-  if (pending_brightness_changes_.empty())
+bool FakePowerManagerClient::ApplyPendingScreenBrightnessChange() {
+  if (pending_screen_brightness_changes_.empty())
     return false;
-  double brightness = pending_brightness_changes_.front();
-  pending_brightness_changes_.pop();
 
-  DCHECK(brightness == 0 || brightness == requested_screen_brightness_percent_);
+  power_manager::BacklightBrightnessChange change =
+      pending_screen_brightness_changes_.front();
+  pending_screen_brightness_changes_.pop();
 
-  screen_brightness_percent_ = brightness;
-  SendBrightnessChanged(brightness, false);
+  screen_brightness_percent_ = change.percent();
+  SendScreenBrightnessChanged(change);
   return true;
 }
 

chromeos/dbus/fake_power_manager_client.h

@@ -16,6 +16,7 @@
 #include "base/observer_list.h"
 #include "base/optional.h"
 #include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
@@ -53,8 +54,9 @@ class CHROMEOS_EXPORT FakePowerManagerClient : public PowerManagerClient {
   void set_enqueue_brightness_changes_on_backlights_forced_off(bool enqueue) {
     enqueue_brightness_changes_on_backlights_forced_off_ = enqueue;
   }
-  const std::queue<double>& pending_brightness_changes() const {
-    return pending_brightness_changes_;
+  const std::queue<power_manager::BacklightBrightnessChange>&
+  pending_screen_brightness_changes() const {
+    return pending_screen_brightness_changes_;
   }
   void set_user_activity_callback(base::RepeatingClosure callback) {
     user_activity_callback_ = std::move(callback);
@@ -104,13 +106,12 @@ class CHROMEOS_EXPORT FakePowerManagerClient : public PowerManagerClient {
   void SendSuspendDone(base::TimeDelta sleep_duration = base::TimeDelta());
   void SendDarkSuspendImminent();
 
-  // Emulates the power manager announcing that the system is changing
-  // display brightness to |level|.
-  void SendBrightnessChanged(int level, bool user_initiated);
-
-  // Emulates the power manager announcing that the system is changing
-  // keyboard brightness to |level|.
-  void SendKeyboardBrightnessChanged(int level, bool user_initiated);
+  // Emulates the power manager announcing that the system is changing the
+  // screen or keyboard brightness.
+  void SendScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& proto);
+  void SendKeyboardBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& proto);
 
   // Notifies observers about the screen idle state changing.
   void SendScreenIdleStateChanged(const power_manager::ScreenIdleState& proto);
@@ -137,10 +138,10 @@ class CHROMEOS_EXPORT FakePowerManagerClient : public PowerManagerClient {
   void SetPowerPolicyQuitClosure(base::OnceClosure quit_closure);
 
   // Updates screen brightness to the first pending value in
-  // |pending_brightness_changes_|.
+  // |pending_screen_brightness_changes_|.
   // Returns whether the screen brightness change was applied - this will
   // return false if there are no pending brightness changes.
-  bool ApplyPendingBrightnessChange();
+  bool ApplyPendingScreenBrightnessChange();
 
   // Sets the screen brightness percent to be returned.
   // The nullopt |percent| means an error. In case of success,
@@ -198,13 +199,14 @@ class CHROMEOS_EXPORT FakePowerManagerClient : public PowerManagerClient {
   // brightness and send a brightness change event (provided undimmed
   // brightness percent is set).
   // If set, brightness changes will be enqueued to
-  // pending_brightness_changes_, and will have to be applied explicitly by
-  // calling ApplyPendingBrightnessChange().
+  // |pending_screen_brightness_changes_|, and will have to be applied
+  // explicitly by calling ApplyPendingScreenBrightnessChange().
   bool enqueue_brightness_changes_on_backlights_forced_off_ = false;
 
-  // Pending brightness changes caused by SetBacklightsForcedOff().
-  // ApplyPendingBrightnessChange() applies the first pending change.
-  std::queue<double> pending_brightness_changes_;
+  // Pending screen brightness changes caused by SetBacklightsForcedOff().
+  // ApplyPendingScreenBrightnessChange() applies the first pending change.
+  std::queue<power_manager::BacklightBrightnessChange>
+      pending_screen_brightness_changes_;
 
   // Delays returned by GetInactivityDelays().
   power_manager::PowerManagementPolicy::Delays inactivity_delays_;

chromeos/dbus/power_manager_client.cc

@@ -25,6 +25,7 @@
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "chromeos/dbus/power_manager/idle.pb.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
@@ -360,19 +361,21 @@ class PowerManagerClientImpl : public PowerManagerClient {
     // brightness level in Chrome as it'll make things less reliable.
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
-        power_manager::kBrightnessChangedSignal,
-        base::Bind(&PowerManagerClientImpl::BrightnessChangedReceived,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&PowerManagerClientImpl::SignalConnected,
-                   weak_ptr_factory_.GetWeakPtr()));
+        power_manager::kScreenBrightnessChangedSignal,
+        base::BindRepeating(
+            &PowerManagerClientImpl::ScreenBrightnessChangedReceived,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::BindOnce(&PowerManagerClientImpl::SignalConnected,
+                       weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kKeyboardBrightnessChangedSignal,
-        base::Bind(&PowerManagerClientImpl::KeyboardBrightnessChangedReceived,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&PowerManagerClientImpl::SignalConnected,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::BindRepeating(
+            &PowerManagerClientImpl::KeyboardBrightnessChangedReceived,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::BindOnce(&PowerManagerClientImpl::SignalConnected,
+                       weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
@@ -503,36 +506,34 @@ class PowerManagerClientImpl : public PowerManagerClient {
     }
   }
 
-  void BrightnessChangedReceived(dbus::Signal* signal) {
+  void ScreenBrightnessChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    int32_t brightness_level = 0;
-    bool user_initiated = 0;
-    if (!(reader.PopInt32(&brightness_level) &&
-          reader.PopBool(&user_initiated))) {
-      POWER_LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
-                       << signal->ToString();
+    power_manager::BacklightBrightnessChange proto;
+    if (!reader.PopArrayOfBytesAsProto(&proto)) {
+      POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
+                       << power_manager::kScreenBrightnessChangedSignal
+                       << " signal";
       return;
     }
-    POWER_LOG(DEBUG) << "Brightness changed to " << brightness_level
-                     << ": user initiated " << user_initiated;
+    POWER_LOG(DEBUG) << "Screen brightness changed to " << proto.percent()
+                     << ": cause " << proto.cause();
     for (auto& observer : observers_)
-      observer.BrightnessChanged(brightness_level, user_initiated);
+      observer.ScreenBrightnessChanged(proto);
   }
 
   void KeyboardBrightnessChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    int32_t brightness_level = 0;
-    bool user_initiated = 0;
-    if (!(reader.PopInt32(&brightness_level) &&
-          reader.PopBool(&user_initiated))) {
-      POWER_LOG(ERROR) << "Keyboard brightness changed signal had incorrect "
-                       << "parameters: " << signal->ToString();
+    power_manager::BacklightBrightnessChange proto;
+    if (!reader.PopArrayOfBytesAsProto(&proto)) {
+      POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
+                       << power_manager::kKeyboardBrightnessChangedSignal
+                       << " signal";
       return;
     }
-    POWER_LOG(DEBUG) << "Keyboard brightness changed to " << brightness_level
-                     << ": user initiated " << user_initiated;
+    POWER_LOG(DEBUG) << "Keyboard brightness changed to " << proto.percent()
+                     << ": cause " << proto.cause();
     for (auto& observer : observers_)
-      observer.KeyboardBrightnessChanged(brightness_level, user_initiated);
+      observer.KeyboardBrightnessChanged(proto);
   }
 
   void ScreenIdleStateChangedReceived(dbus::Signal* signal) {

chromeos/dbus/power_manager_client.h

@@ -21,6 +21,7 @@
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace power_manager {
+class BacklightBrightnessChange;
 class PowerSupplyProperties;
 class ScreenIdleState;
 }
@@ -56,14 +57,12 @@ class CHROMEOS_EXPORT PowerManagerClient : public DBusClient {
     virtual void PowerManagerRestarted() {}
 
     // Called when the screen brightness is changed.
-    // |level| is of the range [0, 100].
-    // |user_initiated| is true if the action is initiated by the user.
-    virtual void BrightnessChanged(int level, bool user_initiated) {}
+    virtual void ScreenBrightnessChanged(
+        const power_manager::BacklightBrightnessChange& change) {}
 
     // Called when the keyboard brightness is changed.
-    // |level| is of the range [0, 100].
-    // |user_initiated| is true if the action is initiated by the user.
-    virtual void KeyboardBrightnessChanged(int level, bool user_initiated) {}
+    virtual void KeyboardBrightnessChanged(
+        const power_manager::BacklightBrightnessChange& change) {}
 
     // Called when screen-related inactivity timeouts are triggered or reset.
     virtual void ScreenIdleStateChanged(

components/arc/power/arc_power_bridge.cc

@@ -12,6 +12,7 @@
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_browser_context_keyed_service_factory_base.h"
@@ -190,18 +191,18 @@ void ArcPowerBridge::SuspendDone(const base::TimeDelta& sleep_duration) {
   power_instance->Resume();
 }
 
-void ArcPowerBridge::BrightnessChanged(int level, bool user_initiated) {
-  double percent = static_cast<double>(level);
+void ArcPowerBridge::ScreenBrightnessChanged(
+    const power_manager::BacklightBrightnessChange& change) {
   const base::TimeTicks now = base::TimeTicks::Now();
   if (last_brightness_changed_time_.is_null() ||
       (now - last_brightness_changed_time_) >= kNotifyBrightnessDelay) {
-    UpdateAndroidScreenBrightness(percent);
+    UpdateAndroidScreenBrightness(change.percent());
     notify_brightness_timer_.Stop();
   } else {
     notify_brightness_timer_.Start(
         FROM_HERE, kNotifyBrightnessDelay,
         base::Bind(&ArcPowerBridge::UpdateAndroidScreenBrightness,
-                   weak_ptr_factory_.GetWeakPtr(), percent));
+                   weak_ptr_factory_.GetWeakPtr(), change.percent()));
   }
   last_brightness_changed_time_ = now;
 }

components/arc/power/arc_power_bridge.h

@@ -64,7 +64,8 @@ class ArcPowerBridge : public KeyedService,
   // chromeos::PowerManagerClient::Observer overrides.
   void SuspendImminent(power_manager::SuspendImminent::Reason reason) override;
   void SuspendDone(const base::TimeDelta& sleep_duration) override;
-  void BrightnessChanged(int level, bool user_initiated) override;
+  void ScreenBrightnessChanged(
+      const power_manager::BacklightBrightnessChange& change) override;
 
   // DisplayConfigurator::Observer overrides.
   void OnPowerStateChanged(chromeos::DisplayPowerState power_state) override;

components/arc/power/arc_power_bridge_unittest.cc

@@ -150,7 +150,10 @@ TEST_F(ArcPowerBridgeTest, ScreenBrightness) {
   // Check that Chrome OS brightness changes are passed to Android.
   const double kUpdatedBrightness = 45.0;
   power_manager_client_->set_screen_brightness_percent(kUpdatedBrightness);
-  power_manager_client_->SendBrightnessChanged(kUpdatedBrightness, true);
+  power_manager::BacklightBrightnessChange change;
+  change.set_percent(kUpdatedBrightness);
+  change.set_cause(power_manager::BacklightBrightnessChange_Cause_USER_REQUEST);
+  power_manager_client_->SendScreenBrightnessChanged(change);
   EXPECT_DOUBLE_EQ(kUpdatedBrightness, power_instance_->screen_brightness());
 
   // Requests from Android should update the Chrome OS brightness.
@@ -162,7 +165,8 @@ TEST_F(ArcPowerBridgeTest, ScreenBrightness) {
   // To prevent battles between Chrome OS and Android, the updated brightness
   // shouldn't be passed to Android immediately, but it should be passed after
   // the timer fires.
-  power_manager_client_->SendBrightnessChanged(kAndroidBrightness, true);
+  change.set_percent(kAndroidBrightness);
+  power_manager_client_->SendScreenBrightnessChanged(change);
   EXPECT_DOUBLE_EQ(kUpdatedBrightness, power_instance_->screen_brightness());
   ASSERT_TRUE(power_bridge_->TriggerNotifyBrightnessTimerForTesting());
   EXPECT_DOUBLE_EQ(kAndroidBrightness, power_instance_->screen_brightness());