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