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

chrome/browser/chromeos/power/power_prefs_unittest.cc

 // Copyright 2013 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 "chrome/browser/chromeos/power/power_prefs.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 28 matching lines @@
 class PowerPrefsTest : public testing::Test {
  protected:
   PowerPrefsTest();
 
   // testing::Test:
   virtual void SetUp() override;
   virtual void TearDown() override;
 
   const Profile* GetProfile() const;
 
-  std::string GetExpectedPowerPolicyForProfile(Profile* profile) const;
+  std::string GetExpectedPowerPolicyForProfile(Profile* profile,
+                                               bool screen_is_locked) const;
   std::string GetCurrentPowerPolicy() const;
   bool GetExpectedAllowScreenWakeLocksForProfile(Profile* profile) const;
   bool GetCurrentAllowScreenWakeLocks() const;
 
   TestingProfileManager profile_manager_;
   PowerPolicyController* power_policy_controller_;     // Not owned.
   scoped_ptr<FakePowerManagerClient> fake_power_manager_client_;
 
   scoped_ptr<PowerPrefs> power_prefs_;
 
@@ skipping 25 matching lines @@
   power_prefs_.reset();
   PowerPolicyController::Shutdown();
   testing::Test::TearDown();
 }
 
 const Profile* PowerPrefsTest::GetProfile() const {
   return power_prefs_->profile_;
 }
 
 std::string PowerPrefsTest::GetExpectedPowerPolicyForProfile(
-    Profile* profile) const {
+    Profile* profile,
+    bool screen_is_locked) const {
   const PrefService* prefs = profile->GetPrefs();
   power_manager::PowerManagementPolicy expected_policy;
   expected_policy.mutable_ac_delays()->set_screen_dim_ms(
-      prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs));
+      prefs->GetInteger(screen_is_locked ? prefs::kPowerLockScreenDimDelayMs :
+          prefs::kPowerAcScreenDimDelayMs));
   expected_policy.mutable_ac_delays()->set_screen_off_ms(
-      prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs));
+      prefs->GetInteger(screen_is_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));
+      prefs->GetInteger(screen_is_locked ? prefs::kPowerLockScreenDimDelayMs :
+          prefs::kPowerBatteryScreenDimDelayMs));
   expected_policy.mutable_battery_delays()->set_screen_off_ms(
-      prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs));
+      prefs->GetInteger(screen_is_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(
       prefs->GetInteger(prefs::kPowerBatteryIdleWarningDelayMs));
   expected_policy.mutable_battery_delays()->set_idle_ms(
       prefs->GetInteger(prefs::kPowerBatteryIdleDelayMs));
   expected_policy.set_ac_idle_action(
       static_cast<power_manager::PowerManagementPolicy_Action>(
             prefs->GetInteger(prefs::kPowerAcIdleAction)));
   expected_policy.set_battery_idle_action(
@@ skipping 41 matching lines @@
   builder.SetPrefService(login_profile_prefs.Pass());
   TestingProfile* login_profile = builder.BuildIncognito(
       profile_manager_.CreateTestingProfile(chrome::kInitialProfile));
 
   // Inform power_prefs_ that the login screen is being shown.
   power_prefs_->Observe(chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                         content::Source<PowerPrefsTest>(this),
                         content::NotificationService::NoDetails());
 
   EXPECT_EQ(login_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, false),

[Daniel Erat, 2014/12/11 00:26:33]

i suspect that you'll ask me to comment all of these boolean arguments, which
will make me sad since the lines will wrap. :-)

[bartfab (slow), 2014/12/12 12:22:37]

Well, there are many simple ways around it:

1) Use a temporary, e.g.:
const bool screen_locked = false;
EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, screen_locked));
2) Add two aptly named wrappers around GetExpectedPowerPolicyForProfile().
3) Switch from a bool to an enum with values like |LOCKED| and |UNLOCKED|.

             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile),
             GetCurrentAllowScreenWakeLocks());
 
   TestingProfile* other_profile =
       profile_manager_.CreateTestingProfile("other");
 
   // Inform power_prefs_ that an unrelated profile has been destroyed.
   power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
                         content::Source<Profile>(other_profile),
                         content::NotificationService::NoDetails());
 
   // 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, false),
             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, true),
+            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, false),
+            GetCurrentPowerPolicy());
+
   // Inform power_prefs_ that the login profile has been destroyed.
   power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
                         content::Source<Profile>(login_profile),
                         content::NotificationService::NoDetails());
 
   // The login profile's prefs should still be used.
   EXPECT_FALSE(GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile, false),
             GetCurrentPowerPolicy());
 }
 
 TEST_F(PowerPrefsTest, UserSession) {
   FakeUserManager* user_manager = new FakeUserManager();
   ScopedUserManagerEnabler user_manager_enabler(user_manager);
 
   // Set up user profile.
   const char test_user1[] = "test-user1@example.com";
   user_manager->AddUser(test_user1);
   user_manager->LoginUser(test_user1);
   TestingProfile* user_profile =
       profile_manager_.CreateTestingProfile(test_user1);
 
   profile_manager_.SetLoggedIn(true);
 
   // Inform power_prefs_ that a session has started.
   power_prefs_->Observe(chrome::NOTIFICATION_SESSION_STARTED,
                         content::Source<PowerPrefsTest>(this),
                         content::NotificationService::NoDetails());
 
   EXPECT_EQ(user_profile, GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, false),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
 
   const char test_user2[] = "test-user2@example.com";
   user_manager->AddUser(test_user2);
   user_manager->LoginUser(test_user2);
   TestingProfile* other_profile =
       profile_manager_.CreateTestingProfile(test_user2);
 
   // Inform power_prefs_ that an unrelated profile has been destroyed.
   power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
                         content::Source<Profile>(other_profile),
                         content::NotificationService::NoDetails());
 
   // 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, false),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
 
   // Simulate the login screen coming up as part of screen locking.
   power_prefs_->Observe(chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                         content::Source<PowerPrefsTest>(this),
                         content::NotificationService::NoDetails());
 
   // 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, false),
             GetCurrentPowerPolicy());
   EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
             GetCurrentAllowScreenWakeLocks());
 
   // Inform power_prefs_ that the session has ended and the user profile has
   // been destroyed.
   power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
                         content::Source<Profile>(user_profile),
                         content::NotificationService::NoDetails());
 
   // The user profile's prefs should still be used.
   EXPECT_FALSE(GetProfile());
-  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile, false),
             GetCurrentPowerPolicy());
 }
 
 }  // namespace chromeos