chromeos: Add separate screen dim/off delays for lock screen

Add power.lock_screen_dim_delay_ms and
power.lock_screen_off_delay_ms prefs that provide alternate
screen-dim and screen-off inactivity delays that are honored
while the screen is locked. They currently default to 30 and
40 seconds, respectively.

BUG=190499

Review URL: https://codereview.chromium.org/793973002

Cr-Commit-Position: refs/heads/master@{#308131}

chrome/browser/chromeos/power/power_prefs.cc

@@ -26,10 +26,14 @@ namespace chromeos {
 
 PowerPrefs::PowerPrefs(PowerPolicyController* power_policy_controller)
     : power_policy_controller_(power_policy_controller),
-      profile_(NULL) {
+      profile_(NULL),
+      screen_is_locked_(false) {
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                               content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
+                              content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_SESSION_STARTED,
                               content::NotificationService::AllSources());
@@ -82,6 +86,12 @@ void PowerPrefs::Observe(int type,
         SetProfile(ProfileHelper::GetSigninProfile());
       break;
     }
+    case chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED:
+      // Update the policy in case different delays have been set for the lock
+      // screen.
+      screen_is_locked_ = *content::Details<bool>(details).ptr();
+      UpdatePowerPolicyFromPrefs();
+      break;
     case chrome::NOTIFICATION_SESSION_STARTED:
       // Update |profile_| when entering a session.
       SetProfile(ProfileManager::GetPrimaryUserProfile());
@@ -108,9 +118,11 @@ void PowerPrefs::UpdatePowerPolicyFromPrefs() {
   const PrefService* prefs = pref_change_registrar_->prefs();
   PowerPolicyController::PrefValues values;
   values.ac_screen_dim_delay_ms =
-      prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs);
+      prefs->GetInteger(screen_is_locked_ ? prefs::kPowerLockScreenDimDelayMs :
+          prefs::kPowerAcScreenDimDelayMs);
   values.ac_screen_off_delay_ms =
-      prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs);
+      prefs->GetInteger(screen_is_locked_ ? prefs::kPowerLockScreenOffDelayMs :
+          prefs::kPowerAcScreenOffDelayMs);
   values.ac_screen_lock_delay_ms =
       prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs);
   values.ac_idle_warning_delay_ms =
@@ -118,9 +130,11 @@ void PowerPrefs::UpdatePowerPolicyFromPrefs() {
   values.ac_idle_delay_ms =
       prefs->GetInteger(prefs::kPowerAcIdleDelayMs);
   values.battery_screen_dim_delay_ms =
-      prefs->GetInteger(prefs::kPowerBatteryScreenDimDelayMs);
+      prefs->GetInteger(screen_is_locked_ ? prefs::kPowerLockScreenDimDelayMs :
+          prefs::kPowerBatteryScreenDimDelayMs);
   values.battery_screen_off_delay_ms =
-      prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs);
+      prefs->GetInteger(screen_is_locked_ ? prefs::kPowerLockScreenOffDelayMs :
+          prefs::kPowerBatteryScreenOffDelayMs);
   values.battery_screen_lock_delay_ms =
       prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs);
   values.battery_idle_warning_delay_ms =
@@ -194,6 +208,14 @@ void PowerPrefs::RegisterProfilePrefs(
       prefs::kPowerBatteryIdleDelayMs,
       600000,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerLockScreenDimDelayMs,
+      30000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerLockScreenOffDelayMs,
+      40000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterIntegerPref(
       prefs::kPowerAcIdleAction,
       PowerPolicyController::ACTION_SUSPEND,
@@ -261,6 +283,10 @@ void PowerPrefs::SetProfile(Profile* profile) {
   pref_change_registrar_->Add(prefs::kPowerBatteryIdleWarningDelayMs,
                               update_callback);
   pref_change_registrar_->Add(prefs::kPowerBatteryIdleDelayMs, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerLockScreenDimDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerLockScreenOffDelayMs,
+                              update_callback);
   pref_change_registrar_->Add(prefs::kPowerAcIdleAction, update_callback);
   pref_change_registrar_->Add(prefs::kPowerBatteryIdleAction, update_callback);
   pref_change_registrar_->Add(prefs::kPowerLidClosedAction, update_callback);

chrome/browser/chromeos/power/power_prefs.h

@@ -60,6 +60,9 @@ class PowerPrefs : public content::NotificationObserver {
   Profile* profile_;  // Not owned.
   scoped_ptr<PrefChangeRegistrar> pref_change_registrar_;
 
+  // True while the screen is locked (but not while the login screen is shown).
+  bool screen_is_locked_;
+
   DISALLOW_COPY_AND_ASSIGN(PowerPrefs);
 };
 

chrome/browser/chromeos/power/power_prefs_unittest.cc

@@ -38,6 +38,13 @@ namespace chromeos {
 
 class PowerPrefsTest : public testing::Test {
  protected:
+  // Screen lock state that determines which delays are used by
+  // GetExpectedPowerPolicyForProfile().
+  enum ScreenLockState {
+    LOCKED,
+    UNLOCKED,
+  };
+
   PowerPrefsTest();
 
   // testing::Test:
@@ -46,7 +53,9 @@ class PowerPrefsTest : public testing::Test {
 
   const Profile* GetProfile() const;
 
-  std::string GetExpectedPowerPolicyForProfile(Profile* profile) const;
+  std::string GetExpectedPowerPolicyForProfile(
+      Profile* profile,
+      ScreenLockState screen_lock_state) const;
   std::string GetCurrentPowerPolicy() const;
   bool GetExpectedAllowScreenWakeLocksForProfile(Profile* profile) const;
   bool GetCurrentAllowScreenWakeLocks() const;
@@ -92,23 +101,28 @@ const Profile* PowerPrefsTest::GetProfile() const {
 }
 
 std::string PowerPrefsTest::GetExpectedPowerPolicyForProfile(
-    Profile* profile) const {
+    Profile* profile,
+    ScreenLockState screen_lock_state) const {
   const PrefService* prefs = profile->GetPrefs();
   power_manager::PowerManagementPolicy expected_policy;
-  expected_policy.mutable_ac_delays()->set_screen_dim_ms(
-      prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs));
-  expected_policy.mutable_ac_delays()->set_screen_off_ms(
-      prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs));
+  expected_policy.mutable_ac_delays()->set_screen_dim_ms(prefs->GetInteger(
+      screen_lock_state == LOCKED ? prefs::kPowerLockScreenDimDelayMs
+                                  : prefs::kPowerAcScreenDimDelayMs));
+  expected_policy.mutable_ac_delays()->set_screen_off_ms(prefs->GetInteger(
+      screen_lock_state == LOCKED ? prefs::kPowerLockScreenOffDelayMs
+                                  : prefs::kPowerAcScreenOffDelayMs));
   expected_policy.mutable_ac_delays()->set_screen_lock_ms(
       prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs));
   expected_policy.mutable_ac_delays()->set_idle_warning_ms(
       prefs->GetInteger(prefs::kPowerAcIdleWarningDelayMs));
   expected_policy.mutable_ac_delays()->set_idle_ms(
       prefs->GetInteger(prefs::kPowerAcIdleDelayMs));
-  expected_policy.mutable_battery_delays()->set_screen_dim_ms(
-      prefs->GetInteger(prefs::kPowerBatteryScreenDimDelayMs));
-  expected_policy.mutable_battery_delays()->set_screen_off_ms(
-      prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs));
+  expected_policy.mutable_battery_delays()->set_screen_dim_ms(prefs->GetInteger(
+      screen_lock_state == LOCKED ? prefs::kPowerLockScreenDimDelayMs
+                                  : prefs::kPowerBatteryScreenDimDelayMs));
+  expected_policy.mutable_battery_delays()->set_screen_off_ms(prefs->GetInteger(
+      screen_lock_state == LOCKED ? prefs::kPowerLockScreenOffDelayMs
+                                  : prefs::kPowerBatteryScreenOffDelayMs));
   expected_policy.mutable_battery_delays()->set_screen_lock_ms(
       prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs));
   expected_policy.mutable_battery_delays()->set_idle_warning_ms(
@@ -170,7 +184,7 @@ TEST_F(PowerPrefsTest, LoginScreen) {
                         content::NotificationService::NoDetails());
 
   EXPECT_EQ(login_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, UNLOCKED),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile),
             GetCurrentAllowScreenWakeLocks());
@@ -185,11 +199,27 @@ TEST_F(PowerPrefsTest, LoginScreen) {
 
   // Verify that the login profile's power prefs are still being used.
   EXPECT_EQ(login_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, UNLOCKED),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile),
             GetCurrentAllowScreenWakeLocks());
 
+  // Lock the screen and check that the expected delays are used.
+  bool screen_is_locked = true;
+  power_prefs_->Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
+                        content::Source<Profile>(login_profile),
+                        content::Details<bool>(&screen_is_locked));
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, LOCKED),
+            GetCurrentPowerPolicy());
+
+  // Unlock the screen.
+  screen_is_locked = false;
+  power_prefs_->Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
+                        content::Source<Profile>(login_profile),
+                        content::Details<bool>(&screen_is_locked));
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, UNLOCKED),
+            GetCurrentPowerPolicy());
+
   // Inform power_prefs_ that the login profile has been destroyed.
   power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
                         content::Source<Profile>(login_profile),
@@ -197,7 +227,7 @@ TEST_F(PowerPrefsTest, LoginScreen) {
 
   // The login profile's prefs should still be used.
   EXPECT_FALSE(GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, UNLOCKED),
             GetCurrentPowerPolicy());
 }
 
@@ -220,7 +250,7 @@ TEST_F(PowerPrefsTest, UserSession) {
                         content::NotificationService::NoDetails());
 
   EXPECT_EQ(user_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, UNLOCKED),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
@@ -238,7 +268,7 @@ TEST_F(PowerPrefsTest, UserSession) {
 
   // Verify that the user profile's power prefs are still being used.
   EXPECT_EQ(user_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, UNLOCKED),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
@@ -250,7 +280,7 @@ TEST_F(PowerPrefsTest, UserSession) {
 
   // Verify that power policy didn't revert to login screen settings.
   EXPECT_EQ(user_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, UNLOCKED),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
@@ -263,7 +293,7 @@ TEST_F(PowerPrefsTest, UserSession) {
 
   // The user profile's prefs should still be used.
   EXPECT_FALSE(GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, UNLOCKED),
             GetCurrentPowerPolicy());
 }
 

chrome/common/pref_names.cc

@@ -715,6 +715,11 @@ const char kPowerBatteryIdleWarningDelayMs[] =
 const char kPowerBatteryIdleDelayMs[] =
     "power.battery_idle_delay_ms";
 
+// Inactivity delays used to dim the screen or turn it off while the screen is
+// locked.
+const char kPowerLockScreenDimDelayMs[] = "power.lock_screen_dim_delay_ms";
+const char kPowerLockScreenOffDelayMs[] = "power.lock_screen_off_delay_ms";
+
 // Action that should be performed when the idle delay is reached while the
 // system is on AC power or battery power.
 // Values are from the chromeos::PowerPolicyController::Action enum.

chrome/common/pref_names.h

@@ -244,6 +244,8 @@ extern const char kPowerBatteryScreenOffDelayMs[];
 extern const char kPowerBatteryScreenLockDelayMs[];
 extern const char kPowerBatteryIdleWarningDelayMs[];
 extern const char kPowerBatteryIdleDelayMs[];
+extern const char kPowerLockScreenDimDelayMs[];
+extern const char kPowerLockScreenOffDelayMs[];
 extern const char kPowerAcIdleAction[];
 extern const char kPowerBatteryIdleAction[];
 extern const char kPowerLidClosedAction[];