1// Copyright 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/chromeos/power/power_prefs.h" 6 7#include <string> 8 9#include "base/command_line.h" 10#include "base/files/file_path.h" 11#include "base/memory/ref_counted.h" 12#include "base/prefs/pref_service.h" 13#include "chrome/browser/chrome_notification_types.h" 14#include "chrome/browser/chromeos/login/users/fake_user_manager.h" 15#include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h" 16#include "chrome/browser/chromeos/profiles/profile_helper.h" 17#include "chrome/browser/extensions/extension_special_storage_policy.h" 18#include "chrome/browser/prefs/browser_prefs.h" 19#include "chrome/browser/prefs/pref_service_syncable.h" 20#include "chrome/browser/profiles/profile.h" 21#include "chrome/browser/profiles/profile_manager.h" 22#include "chrome/common/chrome_constants.h" 23#include "chrome/common/pref_names.h" 24#include "chrome/test/base/testing_browser_process.h" 25#include "chrome/test/base/testing_pref_service_syncable.h" 26#include "chrome/test/base/testing_profile.h" 27#include "chrome/test/base/testing_profile_manager.h" 28#include "chromeos/chromeos_switches.h" 29#include "chromeos/dbus/dbus_thread_manager.h" 30#include "chromeos/dbus/fake_power_manager_client.h" 31#include "chromeos/dbus/power_manager/policy.pb.h" 32#include "chromeos/dbus/power_policy_controller.h" 33#include "components/pref_registry/pref_registry_syncable.h" 34#include "content/public/browser/notification_details.h" 35#include "content/public/browser/notification_service.h" 36#include "content/public/browser/notification_source.h" 37#include "testing/gtest/include/gtest/gtest.h" 38 39namespace chromeos { 40 41class PowerPrefsTest : public testing::Test { 42 protected: 43 PowerPrefsTest(); 44 45 // testing::Test: 46 virtual void SetUp() OVERRIDE; 47 virtual void TearDown() OVERRIDE; 48 49 const Profile* GetProfile() const; 50 51 std::string GetExpectedPowerPolicyForProfile(Profile* profile) const; 52 std::string GetCurrentPowerPolicy() const; 53 bool GetExpectedAllowScreenWakeLocksForProfile(Profile* profile) const; 54 bool GetCurrentAllowScreenWakeLocks() const; 55 56 TestingProfileManager profile_manager_; 57 PowerPolicyController* power_policy_controller_; // Not owned. 58 FakePowerManagerClient* fake_power_manager_client_; // Not owned. 59 60 scoped_ptr<PowerPrefs> power_prefs_; 61 62 DISALLOW_COPY_AND_ASSIGN(PowerPrefsTest); 63}; 64 65PowerPrefsTest::PowerPrefsTest() 66 : profile_manager_(TestingBrowserProcess::GetGlobal()), 67 power_policy_controller_(NULL), 68 fake_power_manager_client_(new FakePowerManagerClient) { 69} 70 71void PowerPrefsTest::SetUp() { 72 testing::Test::SetUp(); 73 74 scoped_ptr<DBusThreadManagerSetter> dbus_setter = 75 chromeos::DBusThreadManager::GetSetterForTesting(); 76 dbus_setter->SetPowerManagerClient( 77 scoped_ptr<PowerManagerClient>(fake_power_manager_client_)); 78 // Power policy controller is recreated with SetPowerManagerClient(). 79 power_policy_controller_ = 80 chromeos::DBusThreadManager::Get()->GetPowerPolicyController(); 81 82 ASSERT_TRUE(profile_manager_.SetUp()); 83 84 power_prefs_.reset(new PowerPrefs(power_policy_controller_)); 85 EXPECT_FALSE(GetProfile()); 86 EXPECT_EQ(PowerPolicyController::GetPolicyDebugString( 87 power_manager::PowerManagementPolicy()), 88 GetCurrentPowerPolicy()); 89} 90 91void PowerPrefsTest::TearDown() { 92 power_prefs_.reset(); 93 testing::Test::TearDown(); 94} 95 96const Profile* PowerPrefsTest::GetProfile() const { 97 return power_prefs_->profile_; 98} 99 100std::string PowerPrefsTest::GetExpectedPowerPolicyForProfile( 101 Profile* profile) const { 102 const PrefService* prefs = profile->GetPrefs(); 103 power_manager::PowerManagementPolicy expected_policy; 104 expected_policy.mutable_ac_delays()->set_screen_dim_ms( 105 prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs)); 106 expected_policy.mutable_ac_delays()->set_screen_off_ms( 107 prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs)); 108 expected_policy.mutable_ac_delays()->set_screen_lock_ms( 109 prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs)); 110 expected_policy.mutable_ac_delays()->set_idle_warning_ms( 111 prefs->GetInteger(prefs::kPowerAcIdleWarningDelayMs)); 112 expected_policy.mutable_ac_delays()->set_idle_ms( 113 prefs->GetInteger(prefs::kPowerAcIdleDelayMs)); 114 expected_policy.mutable_battery_delays()->set_screen_dim_ms( 115 prefs->GetInteger(prefs::kPowerBatteryScreenDimDelayMs)); 116 expected_policy.mutable_battery_delays()->set_screen_off_ms( 117 prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs)); 118 expected_policy.mutable_battery_delays()->set_screen_lock_ms( 119 prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs)); 120 expected_policy.mutable_battery_delays()->set_idle_warning_ms( 121 prefs->GetInteger(prefs::kPowerBatteryIdleWarningDelayMs)); 122 expected_policy.mutable_battery_delays()->set_idle_ms( 123 prefs->GetInteger(prefs::kPowerBatteryIdleDelayMs)); 124 expected_policy.set_ac_idle_action( 125 static_cast<power_manager::PowerManagementPolicy_Action>( 126 prefs->GetInteger(prefs::kPowerAcIdleAction))); 127 expected_policy.set_battery_idle_action( 128 static_cast<power_manager::PowerManagementPolicy_Action>( 129 prefs->GetInteger(prefs::kPowerBatteryIdleAction))); 130 expected_policy.set_lid_closed_action( 131 static_cast<power_manager::PowerManagementPolicy_Action>( 132 prefs->GetInteger(prefs::kPowerLidClosedAction))); 133 expected_policy.set_use_audio_activity( 134 prefs->GetBoolean(prefs::kPowerUseAudioActivity)); 135 expected_policy.set_use_video_activity( 136 prefs->GetBoolean(prefs::kPowerUseVideoActivity)); 137 expected_policy.set_presentation_screen_dim_delay_factor( 138 prefs->GetDouble(prefs::kPowerPresentationScreenDimDelayFactor)); 139 expected_policy.set_user_activity_screen_dim_delay_factor( 140 prefs->GetDouble(prefs::kPowerUserActivityScreenDimDelayFactor)); 141 expected_policy.set_wait_for_initial_user_activity( 142 prefs->GetBoolean(prefs::kPowerWaitForInitialUserActivity)); 143 expected_policy.set_reason("Prefs"); 144 return PowerPolicyController::GetPolicyDebugString(expected_policy); 145} 146 147std::string PowerPrefsTest::GetCurrentPowerPolicy() const { 148 return PowerPolicyController::GetPolicyDebugString( 149 fake_power_manager_client_->policy()); 150} 151 152bool PowerPrefsTest::GetCurrentAllowScreenWakeLocks() const { 153 return power_policy_controller_->honor_screen_wake_locks_; 154} 155 156bool PowerPrefsTest::GetExpectedAllowScreenWakeLocksForProfile( 157 Profile* profile) const { 158 return profile->GetPrefs()->GetBoolean(prefs::kPowerAllowScreenWakeLocks); 159} 160 161TEST_F(PowerPrefsTest, LoginScreen) { 162 // Set up login profile. 163 scoped_ptr<TestingPrefServiceSyncable> login_profile_prefs( 164 new TestingPrefServiceSyncable); 165 chrome::RegisterLoginProfilePrefs(login_profile_prefs->registry()); 166 TestingProfile::Builder builder; 167 builder.SetPath( 168 profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile)); 169 builder.SetPrefService(login_profile_prefs.PassAs<PrefServiceSyncable>()); 170 TestingProfile* login_profile = builder.BuildIncognito( 171 profile_manager_.CreateTestingProfile(chrome::kInitialProfile)); 172 173 // Inform power_prefs_ that the login screen is being shown. 174 power_prefs_->Observe(chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, 175 content::Source<PowerPrefsTest>(this), 176 content::NotificationService::NoDetails()); 177 178 EXPECT_EQ(login_profile, GetProfile()); 179 EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile), 180 GetCurrentPowerPolicy()); 181 EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile), 182 GetCurrentAllowScreenWakeLocks()); 183 184 TestingProfile* other_profile = 185 profile_manager_.CreateTestingProfile("other"); 186 187 // Inform power_prefs_ that an unrelated profile has been destroyed. 188 power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED, 189 content::Source<Profile>(other_profile), 190 content::NotificationService::NoDetails()); 191 192 // Verify that the login profile's power prefs are still being used. 193 EXPECT_EQ(login_profile, GetProfile()); 194 EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile), 195 GetCurrentPowerPolicy()); 196 EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile), 197 GetCurrentAllowScreenWakeLocks()); 198 199 // Inform power_prefs_ that the login profile has been destroyed. 200 power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED, 201 content::Source<Profile>(login_profile), 202 content::NotificationService::NoDetails()); 203 204 // The login profile's prefs should still be used. 205 EXPECT_FALSE(GetProfile()); 206 EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile), 207 GetCurrentPowerPolicy()); 208} 209 210TEST_F(PowerPrefsTest, UserSession) { 211 FakeUserManager* user_manager = new FakeUserManager(); 212 ScopedUserManagerEnabler user_manager_enabler(user_manager); 213 214 // Set up user profile. 215 const char test_user1[] = "test-user1@example.com"; 216 user_manager->AddUser(test_user1); 217 user_manager->LoginUser(test_user1); 218 TestingProfile* user_profile = 219 profile_manager_.CreateTestingProfile(test_user1); 220 221 profile_manager_.SetLoggedIn(true); 222 223 // Inform power_prefs_ that a session has started. 224 power_prefs_->Observe(chrome::NOTIFICATION_SESSION_STARTED, 225 content::Source<PowerPrefsTest>(this), 226 content::NotificationService::NoDetails()); 227 228 EXPECT_EQ(user_profile, GetProfile()); 229 EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile), 230 GetCurrentPowerPolicy()); 231 EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile), 232 GetCurrentAllowScreenWakeLocks()); 233 234 const char test_user2[] = "test-user2@example.com"; 235 user_manager->AddUser(test_user2); 236 user_manager->LoginUser(test_user2); 237 TestingProfile* other_profile = 238 profile_manager_.CreateTestingProfile(test_user2); 239 240 // Inform power_prefs_ that an unrelated profile has been destroyed. 241 power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED, 242 content::Source<Profile>(other_profile), 243 content::NotificationService::NoDetails()); 244 245 // Verify that the user profile's power prefs are still being used. 246 EXPECT_EQ(user_profile, GetProfile()); 247 EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile), 248 GetCurrentPowerPolicy()); 249 EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile), 250 GetCurrentAllowScreenWakeLocks()); 251 252 // Simulate the login screen coming up as part of screen locking. 253 power_prefs_->Observe(chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, 254 content::Source<PowerPrefsTest>(this), 255 content::NotificationService::NoDetails()); 256 257 // Verify that power policy didn't revert to login screen settings. 258 EXPECT_EQ(user_profile, GetProfile()); 259 EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile), 260 GetCurrentPowerPolicy()); 261 EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile), 262 GetCurrentAllowScreenWakeLocks()); 263 264 // Inform power_prefs_ that the session has ended and the user profile has 265 // been destroyed. 266 power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED, 267 content::Source<Profile>(user_profile), 268 content::NotificationService::NoDetails()); 269 270 // The user profile's prefs should still be used. 271 EXPECT_FALSE(GetProfile()); 272 EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile), 273 GetCurrentPowerPolicy()); 274} 275 276} // namespace chromeos 277