power_policy_browsertest.cc revision 2385ea399aae016c0806a4f9ef3c9cfe3d2a39df 
1// Copyright (c) 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 <string>
6#include <vector>
7
8#include "base/basictypes.h"
9#include "base/bind.h"
10#include "base/callback.h"
11#include "base/command_line.h"
12#include "base/compiler_specific.h"
13#include "base/file_util.h"
14#include "base/files/file_path.h"
15#include "base/location.h"
16#include "base/message_loop/message_loop.h"
17#include "base/path_service.h"
18#include "base/run_loop.h"
19#include "chrome/browser/browser_process.h"
20#include "chrome/browser/chrome_notification_types.h"
21#include "chrome/browser/chromeos/login/user_manager.h"
22#include "chrome/browser/chromeos/policy/device_policy_builder.h"
23#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
24#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
25#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
26#include "chrome/browser/chromeos/profiles/profile_helper.h"
27#include "chrome/browser/chromeos/settings/device_settings_service.h"
28#include "chrome/browser/extensions/api/power/power_api_manager.h"
29#include "chrome/browser/lifetime/application_lifetime.h"
30#include "chrome/browser/policy/cloud/cloud_policy_core.h"
31#include "chrome/browser/policy/cloud/cloud_policy_store.h"
32#include "chrome/browser/policy/cloud/policy_builder.h"
33#include "chrome/browser/policy/external_data_fetcher.h"
34#include "chrome/browser/policy/mock_policy_service.h"
35#include "chrome/browser/policy/policy_service.h"
36#include "chrome/browser/policy/profile_policy_connector.h"
37#include "chrome/browser/policy/profile_policy_connector_factory.h"
38#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
39#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
40#include "chrome/browser/profiles/profile.h"
41#include "chrome/browser/profiles/profile_manager.h"
42#include "chrome/common/extensions/api/power.h"
43#include "chrome/test/base/testing_profile.h"
44#include "chromeos/chromeos_paths.h"
45#include "chromeos/chromeos_switches.h"
46#include "chromeos/dbus/fake_power_manager_client.h"
47#include "chromeos/dbus/fake_session_manager_client.h"
48#include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
49#include "chromeos/dbus/power_manager/policy.pb.h"
50#include "chromeos/dbus/power_policy_controller.h"
51#include "content/public/browser/notification_details.h"
52#include "content/public/browser/notification_service.h"
53#include "content/public/browser/notification_source.h"
54#include "content/public/test/test_utils.h"
55#include "crypto/rsa_private_key.h"
56#include "testing/gmock/include/gmock/gmock.h"
57#include "testing/gtest/include/gtest/gtest.h"
58
59namespace em = enterprise_management;
60namespace pm = power_manager;
61
62using ::testing::AnyNumber;
63using ::testing::InvokeWithoutArgs;
64using ::testing::_;
65
66namespace policy {
67
68namespace {
69
70const char kLoginScreenPowerManagementPolicy[] =
71    "{"
72    "  \"AC\": {"
73    "    \"Delays\": {"
74    "      \"ScreenDim\": 5000,"
75    "      \"ScreenOff\": 7000,"
76    "      \"Idle\": 9000"
77    "    },"
78    "    \"IdleAction\": \"DoNothing\""
79    "  },"
80    "  \"Battery\": {"
81    "    \"Delays\": {"
82    "      \"ScreenDim\": 1000,"
83    "      \"ScreenOff\": 3000,"
84    "      \"Idle\": 4000"
85    "    },"
86    "    \"IdleAction\": \"DoNothing\""
87    "  },"
88    "  \"LidCloseAction\": \"DoNothing\","
89    "  \"UserActivityScreenDimDelayScale\": 300"
90    "}";
91
92}  // namespace
93
94class PowerPolicyBrowserTestBase : public DevicePolicyCrosBrowserTest {
95 protected:
96  PowerPolicyBrowserTestBase();
97
98  // DevicePolicyCrosBrowserTest:
99  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
100  virtual void SetUpOnMainThread() OVERRIDE;
101
102  void InstallUserKey();
103  void StoreAndReloadUserPolicy();
104
105  void StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
106
107  // Returns a string describing |policy|.
108  std::string GetDebugString(const pm::PowerManagementPolicy& policy);
109
110  UserPolicyBuilder user_policy_;
111
112  chromeos::FakePowerManagerClient* power_manager_client_;
113
114 private:
115  // Runs |closure| and waits for |profile|'s user policy to be updated as a
116  // result.
117  void RunClosureAndWaitForUserPolicyUpdate(const base::Closure& closure,
118                                            Profile* profile);
119
120  // Reloads user policy for |profile| from session manager client.
121  void ReloadUserPolicy(Profile* profile);
122
123  DISALLOW_COPY_AND_ASSIGN(PowerPolicyBrowserTestBase);
124};
125
126class PowerPolicyLoginScreenBrowserTest : public PowerPolicyBrowserTestBase {
127 protected:
128  PowerPolicyLoginScreenBrowserTest();
129
130  // PowerPolicyBrowserTestBase:
131  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
132  virtual void SetUpOnMainThread() OVERRIDE;
133  virtual void CleanUpOnMainThread() OVERRIDE;
134
135  DISALLOW_COPY_AND_ASSIGN(PowerPolicyLoginScreenBrowserTest);
136};
137
138class PowerPolicyInSessionBrowserTest : public PowerPolicyBrowserTestBase {
139 protected:
140  PowerPolicyInSessionBrowserTest();
141
142  // PowerPolicyBrowserTestBase:
143  virtual void SetUpOnMainThread() OVERRIDE;
144
145  DISALLOW_COPY_AND_ASSIGN(PowerPolicyInSessionBrowserTest);
146};
147
148PowerPolicyBrowserTestBase::PowerPolicyBrowserTestBase()
149    : power_manager_client_(NULL) {
150}
151
152void PowerPolicyBrowserTestBase::SetUpInProcessBrowserTestFixture() {
153  DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
154
155  // Initialize device policy.
156  InstallOwnerKey();
157  MarkAsEnterpriseOwned();
158
159  power_manager_client_ =
160      mock_dbus_thread_manager()->fake_power_manager_client();
161}
162
163void PowerPolicyBrowserTestBase::SetUpOnMainThread() {
164  DevicePolicyCrosBrowserTest::SetUpOnMainThread();
165
166  // Initialize user policy.
167  InstallUserKey();
168  user_policy_.policy_data().set_username(chromeos::UserManager::kStubUser);
169}
170
171void PowerPolicyBrowserTestBase::InstallUserKey() {
172  base::FilePath user_keys_dir;
173  ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &user_keys_dir));
174  base::FilePath user_key_file =
175      user_keys_dir.AppendASCII(chromeos::UserManager::kStubUser)
176                   .AppendASCII("policy.pub");
177  std::vector<uint8> user_key_bits;
178  ASSERT_TRUE(user_policy_.GetSigningKey()->ExportPublicKey(&user_key_bits));
179  ASSERT_TRUE(file_util::CreateDirectory(user_key_file.DirName()));
180  ASSERT_EQ(file_util::WriteFile(
181                user_key_file,
182                reinterpret_cast<const char*>(user_key_bits.data()),
183                user_key_bits.size()),
184            static_cast<int>(user_key_bits.size()));
185}
186
187void PowerPolicyBrowserTestBase::StoreAndReloadUserPolicy() {
188  ProfileManager* profile_manager = g_browser_process->profile_manager();
189  Profile* profile = profile_manager->GetProfileByPath(
190      profile_manager->user_data_dir().Append(
191          TestingProfile::kTestUserProfileDir));
192  ASSERT_TRUE(profile);
193
194  // Install the new user policy blob in session manager client.
195  user_policy_.Build();
196  session_manager_client()->set_user_policy(
197      user_policy_.policy_data().username(),
198      user_policy_.GetBlob());
199
200  // Reload user policy from session manager client and wait for the update to
201  // take effect.
202  RunClosureAndWaitForUserPolicyUpdate(
203      base::Bind(&PowerPolicyBrowserTestBase::ReloadUserPolicy, this, profile),
204      profile);
205}
206
207void PowerPolicyBrowserTestBase::
208    StoreAndReloadDevicePolicyAndWaitForLoginProfileChange() {
209  Profile* profile = chromeos::ProfileHelper::GetSigninProfile();
210  ASSERT_TRUE(profile);
211
212  // Install the new device policy blob in session manager client, reload device
213  // policy from session manager client and wait for a change in the login
214  // profile's policy to be observed.
215  RunClosureAndWaitForUserPolicyUpdate(
216      base::Bind(&PowerPolicyBrowserTestBase::RefreshDevicePolicy, this),
217      profile);
218}
219
220std::string PowerPolicyBrowserTestBase::GetDebugString(
221    const pm::PowerManagementPolicy& policy) {
222  return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
223}
224
225void PowerPolicyBrowserTestBase::RunClosureAndWaitForUserPolicyUpdate(
226    const base::Closure& closure,
227    Profile* profile) {
228  base::RunLoop run_loop;
229  MockPolicyServiceObserver observer;
230  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
231      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
232  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
233  PolicyService* policy_service =
234      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
235  ASSERT_TRUE(policy_service);
236  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
237  closure.Run();
238  run_loop.Run();
239  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
240}
241
242void PowerPolicyBrowserTestBase::ReloadUserPolicy(Profile* profile) {
243  UserCloudPolicyManagerChromeOS* policy_manager =
244      UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
245  ASSERT_TRUE(policy_manager);
246  policy_manager->core()->store()->Load();
247}
248
249PowerPolicyLoginScreenBrowserTest::PowerPolicyLoginScreenBrowserTest() {
250}
251
252void PowerPolicyLoginScreenBrowserTest::SetUpCommandLine(
253    CommandLine* command_line) {
254  PowerPolicyBrowserTestBase::SetUpCommandLine(command_line);
255  command_line->AppendSwitch(chromeos::switches::kLoginManager);
256  command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
257}
258
259void PowerPolicyLoginScreenBrowserTest::SetUpOnMainThread() {
260  PowerPolicyBrowserTestBase::SetUpOnMainThread();
261
262  // Wait for the login screen to be shown.
263  content::WindowedNotificationObserver(
264      chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
265      content::NotificationService::AllSources()).Wait();
266}
267
268void PowerPolicyLoginScreenBrowserTest::CleanUpOnMainThread() {
269  base::MessageLoop::current()->PostTask(FROM_HERE,
270                                         base::Bind(&chrome::AttemptExit));
271  base::RunLoop().RunUntilIdle();
272  PowerPolicyBrowserTestBase::CleanUpOnMainThread();
273}
274
275PowerPolicyInSessionBrowserTest::PowerPolicyInSessionBrowserTest() {
276}
277
278void PowerPolicyInSessionBrowserTest::SetUpOnMainThread() {
279  PowerPolicyBrowserTestBase::SetUpOnMainThread();
280
281  // Tell the DeviceSettingsService that there is no local owner.
282  chromeos::DeviceSettingsService::Get()->SetUsername(std::string());
283}
284
285// Verifies that device policy is applied on the login screen.
286IN_PROC_BROWSER_TEST_F(PowerPolicyLoginScreenBrowserTest, SetDevicePolicy) {
287  pm::PowerManagementPolicy power_management_policy =
288      power_manager_client_->get_policy();
289  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
290  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
291  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
292  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
293  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
294  power_management_policy.mutable_battery_delays()->set_idle_ms(4000);
295  power_management_policy.set_ac_idle_action(
296      pm::PowerManagementPolicy::DO_NOTHING);
297  power_management_policy.set_battery_idle_action(
298      pm::PowerManagementPolicy::DO_NOTHING);
299  power_management_policy.set_lid_closed_action(
300      pm::PowerManagementPolicy::DO_NOTHING);
301  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
302
303  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
304  proto.mutable_login_screen_power_management()->
305      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
306  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
307  EXPECT_EQ(GetDebugString(power_management_policy),
308            GetDebugString(power_manager_client_->get_policy()));
309}
310
311// Verifies that device policy is ignored during a session.
312IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetDevicePolicy) {
313  pm::PowerManagementPolicy power_management_policy =
314      power_manager_client_->get_policy();
315
316  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
317  proto.mutable_login_screen_power_management()->
318      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
319  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
320  EXPECT_EQ(GetDebugString(power_management_policy),
321            GetDebugString(power_manager_client_->get_policy()));
322}
323
324// Verifies that user policy is applied during a session.
325IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetUserPolicy) {
326  pm::PowerManagementPolicy power_management_policy =
327      power_manager_client_->get_policy();
328  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
329  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
330  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
331  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
332  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
333  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
334  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
335  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
336  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
337  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
338  power_management_policy.set_use_audio_activity(false);
339  power_management_policy.set_use_video_activity(false);
340  power_management_policy.set_ac_idle_action(
341      pm::PowerManagementPolicy::STOP_SESSION);
342  power_management_policy.set_battery_idle_action(
343      pm::PowerManagementPolicy::STOP_SESSION);
344  power_management_policy.set_lid_closed_action(
345      pm::PowerManagementPolicy::STOP_SESSION);
346  power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
347  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
348
349  user_policy_.payload().mutable_screendimdelayac()->set_value(5000);
350  user_policy_.payload().mutable_screenlockdelayac()->set_value(6000);
351  user_policy_.payload().mutable_screenoffdelayac()->set_value(7000);
352  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8000);
353  user_policy_.payload().mutable_idledelayac()->set_value(9000);
354  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1000);
355  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2000);
356  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3000);
357  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4000);
358  user_policy_.payload().mutable_idledelaybattery()->set_value(5000);
359  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
360      false);
361  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
362      false);
363  user_policy_.payload().mutable_idleactionac()->set_value(
364      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
365  user_policy_.payload().mutable_idleactionbattery()->set_value(
366      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
367  user_policy_.payload().mutable_lidcloseaction()->set_value(
368      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
369  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
370      300);
371  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
372      300);
373  StoreAndReloadUserPolicy();
374  EXPECT_EQ(GetDebugString(power_management_policy),
375            GetDebugString(power_manager_client_->get_policy()));
376}
377
378// Verifies that screen wake locks can be enabled and disabled by extensions and
379// user policy during a session.
380IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, AllowScreenWakeLocks) {
381  pm::PowerManagementPolicy baseline_policy =
382      power_manager_client_->get_policy();
383
384  // Default settings should have delays.
385  pm::PowerManagementPolicy power_management_policy = baseline_policy;
386  EXPECT_NE(0, baseline_policy.ac_delays().screen_dim_ms());
387  EXPECT_NE(0, baseline_policy.ac_delays().screen_off_ms());
388  EXPECT_NE(0, baseline_policy.battery_delays().screen_dim_ms());
389  EXPECT_NE(0, baseline_policy.battery_delays().screen_off_ms());
390
391  // Pretend an extension grabs a screen wake lock.
392  const char kExtensionId[] = "abcdefghijklmnopabcdefghijlkmnop";
393  extensions::PowerApiManager::GetInstance()->AddRequest(
394      kExtensionId, extensions::api::power::LEVEL_DISPLAY);
395  base::RunLoop().RunUntilIdle();
396
397  // Check that the lock is in effect (ignoring ac_idle_action,
398  // battery_idle_action and reason).
399  pm::PowerManagementPolicy policy = baseline_policy;
400  policy.mutable_ac_delays()->set_screen_dim_ms(0);
401  policy.mutable_ac_delays()->set_screen_off_ms(0);
402  policy.mutable_battery_delays()->set_screen_dim_ms(0);
403  policy.mutable_battery_delays()->set_screen_off_ms(0);
404  policy.set_ac_idle_action(
405      power_manager_client_->get_policy().ac_idle_action());
406  policy.set_battery_idle_action(
407      power_manager_client_->get_policy().battery_idle_action());
408  policy.set_reason(power_manager_client_->get_policy().reason());
409  EXPECT_EQ(GetDebugString(policy),
410            GetDebugString(power_manager_client_->get_policy()));
411
412  // Engage the user policy and verify that the defaults take effect again.
413  user_policy_.payload().mutable_allowscreenwakelocks()->set_value(false);
414  StoreAndReloadUserPolicy();
415  policy = baseline_policy;
416  policy.set_ac_idle_action(
417      power_manager_client_->get_policy().ac_idle_action());
418  policy.set_battery_idle_action(
419      power_manager_client_->get_policy().battery_idle_action());
420  policy.set_reason(power_manager_client_->get_policy().reason());
421  EXPECT_EQ(GetDebugString(policy),
422            GetDebugString(power_manager_client_->get_policy()));
423}
424
425}  // namespace policy
426