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