power_policy_browsertest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
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
7#include "base/compiler_specific.h"
8#include "base/run_loop.h"
9#include "base/values.h"
10#include "chrome/browser/extensions/api/power/power_api_manager.h"
11#include "chrome/browser/policy/browser_policy_connector.h"
12#include "chrome/browser/policy/mock_configuration_policy_provider.h"
13#include "chrome/browser/policy/policy_map.h"
14#include "chrome/browser/policy/policy_types.h"
15#include "chrome/common/extensions/api/power.h"
16#include "chrome/test/base/in_process_browser_test.h"
17#include "chromeos/dbus/dbus_thread_manager.h"
18#include "chromeos/dbus/mock_dbus_thread_manager.h"
19#include "chromeos/dbus/mock_power_manager_client.h"
20#include "chromeos/dbus/mock_session_manager_client.h"
21#include "chromeos/dbus/mock_update_engine_client.h"
22#include "chromeos/dbus/power_manager/policy.pb.h"
23#include "chromeos/dbus/power_policy_controller.h"
24#include "policy/policy_constants.h"
25#include "testing/gmock/include/gmock/gmock.h"
26
27namespace policy {
28
29namespace {
30
31using ::testing::AnyNumber;
32using ::testing::AtLeast;
33using ::testing::Mock;
34using ::testing::Return;
35using ::testing::SaveArg;
36using ::testing::_;
37
38namespace pm = power_manager;
39
40}  // namespace
41
42class PowerPolicyBrowserTest : public InProcessBrowserTest {
43 protected:
44  // InProcessBrowserTest:
45  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
46
47  // Sets |user_policy_name| to |user_policy_value|.
48  void SetUserPolicy(const std::string& user_policy_name,
49                     base::Value* user_policy_value);
50
51  // Returns a string describing |policy|.
52  std::string GetDebugString(const pm::PowerManagementPolicy& policy);
53
54  chromeos::MockPowerManagerClient* power_manager_client_;
55
56  // Last PowerManagementPolicy sent by |power_manager_client_|.
57  pm::PowerManagementPolicy last_power_management_policy_;
58
59 private:
60  MockConfigurationPolicyProvider provider_;
61};
62
63void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
64  chromeos::MockDBusThreadManager* dbus_thread_manager =
65      new chromeos::MockDBusThreadManager;
66  power_manager_client_ = dbus_thread_manager->mock_power_manager_client();
67
68  // Capture the PowerManagementPolicy that's sent before tests start
69  // making changes to the user policy.
70  EXPECT_CALL(*power_manager_client_, SetPolicy(_))
71      .WillRepeatedly(SaveArg<0>(&last_power_management_policy_));
72
73  // Ignore uninteresting calls.
74  EXPECT_CALL(*power_manager_client_, AddObserver(_))
75      .Times(AnyNumber());
76  EXPECT_CALL(*power_manager_client_, RemoveObserver(_))
77      .Times(AnyNumber());
78
79  chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager);
80  EXPECT_CALL(*dbus_thread_manager->mock_session_manager_client(),
81              RetrieveUserPolicy(_));
82  EXPECT_CALL(provider_, IsInitializationComplete(_))
83      .WillRepeatedly(Return(true));
84  EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber());
85  BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
86}
87
88void PowerPolicyBrowserTest::SetUserPolicy(
89    const std::string& user_policy_name,
90    base::Value* user_policy_value) {
91  PolicyMap policy_map;
92  policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
93                 user_policy_value);
94  provider_.UpdateChromePolicy(policy_map);
95  base::RunLoop().RunUntilIdle();
96}
97
98std::string PowerPolicyBrowserTest::GetDebugString(
99    const pm::PowerManagementPolicy& policy) {
100  return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
101}
102
103IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
104  pm::PowerManagementPolicy original_power_management_policy =
105      last_power_management_policy_;
106
107  pm::PowerManagementPolicy power_management_policy =
108      original_power_management_policy;
109  power_management_policy.set_idle_action(
110      pm::PowerManagementPolicy::STOP_SESSION);
111  SetUserPolicy(
112      key::kIdleAction,
113      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
114  EXPECT_EQ(GetDebugString(power_management_policy),
115            GetDebugString(last_power_management_policy_));
116
117  power_management_policy = original_power_management_policy;
118  power_management_policy.set_lid_closed_action(
119      pm::PowerManagementPolicy::STOP_SESSION);
120  SetUserPolicy(
121      key::kLidCloseAction,
122      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
123  EXPECT_EQ(GetDebugString(power_management_policy),
124            GetDebugString(last_power_management_policy_));
125
126  power_management_policy = original_power_management_policy;
127  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
128  SetUserPolicy(key::kIdleDelayAC, base::Value::CreateIntegerValue(9000));
129  EXPECT_EQ(GetDebugString(power_management_policy),
130            GetDebugString(last_power_management_policy_));
131
132  power_management_policy = original_power_management_policy;
133  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
134  SetUserPolicy(key::kIdleWarningDelayAC,
135                base::Value::CreateIntegerValue(8000));
136  EXPECT_EQ(GetDebugString(power_management_policy),
137            GetDebugString(last_power_management_policy_));
138
139  power_management_policy = original_power_management_policy;
140  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
141  SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
142  EXPECT_EQ(GetDebugString(power_management_policy),
143            GetDebugString(last_power_management_policy_));
144
145  power_management_policy = original_power_management_policy;
146  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
147  SetUserPolicy(key::kScreenDimDelayAC, base::Value::CreateIntegerValue(5000));
148  EXPECT_EQ(GetDebugString(power_management_policy),
149            GetDebugString(last_power_management_policy_));
150
151  power_management_policy = original_power_management_policy;
152  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
153  SetUserPolicy(key::kScreenLockDelayAC, base::Value::CreateIntegerValue(6000));
154  EXPECT_EQ(GetDebugString(power_management_policy),
155            GetDebugString(last_power_management_policy_));
156
157  power_management_policy = original_power_management_policy;
158  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
159  SetUserPolicy(key::kIdleDelayBattery, base::Value::CreateIntegerValue(5000));
160  EXPECT_EQ(GetDebugString(power_management_policy),
161            GetDebugString(last_power_management_policy_));
162
163  power_management_policy = original_power_management_policy;
164  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
165  SetUserPolicy(key::kIdleWarningDelayBattery,
166                base::Value::CreateIntegerValue(4000));
167  EXPECT_EQ(GetDebugString(power_management_policy),
168            GetDebugString(last_power_management_policy_));
169
170  power_management_policy = original_power_management_policy;
171  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
172  SetUserPolicy(key::kScreenOffDelayBattery,
173                base::Value::CreateIntegerValue(3000));
174  EXPECT_EQ(GetDebugString(power_management_policy),
175            GetDebugString(last_power_management_policy_));
176
177  power_management_policy = original_power_management_policy;
178  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
179  SetUserPolicy(key::kScreenDimDelayBattery,
180                base::Value::CreateIntegerValue(1000));
181  EXPECT_EQ(GetDebugString(power_management_policy),
182            GetDebugString(last_power_management_policy_));
183
184  power_management_policy = original_power_management_policy;
185  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
186  SetUserPolicy(key::kScreenLockDelayBattery,
187                base::Value::CreateIntegerValue(2000));
188  EXPECT_EQ(GetDebugString(power_management_policy),
189            GetDebugString(last_power_management_policy_));
190
191  power_management_policy = original_power_management_policy;
192  power_management_policy.set_use_audio_activity(false);
193  SetUserPolicy(key::kPowerManagementUsesAudioActivity,
194                base::Value::CreateBooleanValue(false));
195  EXPECT_EQ(GetDebugString(power_management_policy),
196            GetDebugString(last_power_management_policy_));
197
198  power_management_policy = original_power_management_policy;
199  power_management_policy.set_use_video_activity(false);
200  SetUserPolicy(key::kPowerManagementUsesVideoActivity,
201                base::Value::CreateBooleanValue(false));
202  EXPECT_EQ(GetDebugString(power_management_policy),
203            GetDebugString(last_power_management_policy_));
204
205  power_management_policy = original_power_management_policy;
206  power_management_policy.set_presentation_idle_delay_factor(3.0);
207  SetUserPolicy(key::kPresentationIdleDelayScale,
208                base::Value::CreateIntegerValue(300));
209  EXPECT_EQ(GetDebugString(power_management_policy),
210            GetDebugString(last_power_management_policy_));
211}
212
213IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, AllowScreenWakeLocks) {
214  pm::PowerManagementPolicy baseline_policy = last_power_management_policy_;
215
216  // Default settings should have delays.
217  pm::PowerManagementPolicy power_management_policy = baseline_policy;
218  EXPECT_NE(0, baseline_policy.ac_delays().screen_dim_ms());
219  EXPECT_NE(0, baseline_policy.ac_delays().screen_off_ms());
220  EXPECT_NE(0, baseline_policy.battery_delays().screen_dim_ms());
221  EXPECT_NE(0, baseline_policy.battery_delays().screen_off_ms());
222
223  // Pretend an extension grabs a screen wake lock.
224  const char kExtensionId[] = "abcdefghijklmnopabcdefghijlkmnop";
225  extensions::PowerApiManager::GetInstance()->AddRequest(
226      kExtensionId, extensions::api::power::LEVEL_DISPLAY);
227  base::RunLoop().RunUntilIdle();
228
229  // Check that the lock is in effect (ignoring idle_action and reason).
230  pm::PowerManagementPolicy policy = baseline_policy;
231  policy.mutable_ac_delays()->set_screen_dim_ms(0);
232  policy.mutable_ac_delays()->set_screen_off_ms(0);
233  policy.mutable_battery_delays()->set_screen_dim_ms(0);
234  policy.mutable_battery_delays()->set_screen_off_ms(0);
235  policy.set_idle_action(last_power_management_policy_.idle_action());
236  policy.set_reason(last_power_management_policy_.reason());
237  EXPECT_EQ(GetDebugString(policy),
238            GetDebugString(last_power_management_policy_));
239
240  // Engage the policy and verify that the defaults take effect again.
241  SetUserPolicy(key::kAllowScreenWakeLocks,
242                base::Value::CreateBooleanValue(false));
243  policy = baseline_policy;
244  policy.set_idle_action(last_power_management_policy_.idle_action());
245  policy.set_reason(last_power_management_policy_.reason());
246  EXPECT_EQ(GetDebugString(policy),
247            GetDebugString(last_power_management_policy_));
248}
249
250}  // namespace policy
251