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