OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 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/ui/webui/settings/chromeos/device_power_handler.h" | |
6 | |
7 #include <memory> | |
8 | |
9 #include "ash/system/power/power_status.h" | |
10 #include "base/json/json_writer.h" | |
11 #include "base/macros.h" | |
12 #include "base/memory/ptr_util.h" | |
13 #include "base/run_loop.h" | |
14 #include "base/test/scoped_task_environment.h" | |
15 #include "base/values.h" | |
16 #include "chrome/browser/chromeos/power/power_prefs.h" | |
17 #include "chrome/common/pref_names.h" | |
18 #include "chromeos/dbus/dbus_thread_manager.h" | |
19 #include "chromeos/dbus/fake_power_manager_client.h" | |
20 #include "chromeos/dbus/power_policy_controller.h" | |
21 #include "components/sync_preferences/testing_pref_service_syncable.h" | |
22 #include "content/public/test/test_web_ui.h" | |
23 #include "testing/gtest/include/gtest/gtest.h" | |
24 | |
25 namespace chromeos { | |
26 namespace settings { | |
27 | |
28 class TestPowerHandler : public PowerHandler { | |
29 public: | |
30 explicit TestPowerHandler(PrefService* prefs) : PowerHandler(prefs) {} | |
31 | |
32 // Pull WebUIMessageHandler::set_web_ui() into public so tests can call it. | |
33 using PowerHandler::set_web_ui; | |
34 }; | |
35 | |
36 class PowerHandlerTest : public testing::Test { | |
37 public: | |
38 PowerHandlerTest() { | |
39 // This initializes chromeos::DBusThreadManager. | |
40 std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter = | |
41 chromeos::DBusThreadManager::GetSetterForTesting(); | |
42 power_manager_client_ = new chromeos::FakePowerManagerClient(); | |
43 dbus_setter->SetPowerManagerClient(base::WrapUnique(power_manager_client_)); | |
michaelpg
2017/06/16 01:35:00
nit: base::MakeUnique<>() then set power_manager_c
Daniel Erat
2017/06/16 02:34:25
done (although the downside is that this requires
| |
44 ash::PowerStatus::Initialize(); | |
45 | |
46 chromeos::PowerPrefs::RegisterUserProfilePrefs(prefs_.registry()); | |
47 | |
48 handler_ = base::MakeUnique<TestPowerHandler>(&prefs_); | |
49 test_api_ = base::MakeUnique<PowerHandler::TestAPI>(handler_.get()); | |
50 handler_->set_web_ui(&web_ui_); | |
51 handler_->RegisterMessages(); | |
52 handler_->AllowJavascriptForTesting(); | |
53 base::RunLoop().RunUntilIdle(); | |
54 } | |
55 | |
56 ~PowerHandlerTest() override { | |
57 handler_.reset(); | |
58 ash::PowerStatus::Shutdown(); | |
59 chromeos::DBusThreadManager::Shutdown(); | |
60 } | |
61 | |
62 protected: | |
63 // Returns a JSON representation of the contents of the last message sent to | |
64 // WebUI about settings being changed. | |
65 std::string GetLastSettingsChangedMessage() WARN_UNUSED_RESULT { | |
66 for (auto it = web_ui_.call_data().rbegin(); | |
67 it != web_ui_.call_data().rend(); ++it) { | |
68 const content::TestWebUI::CallData* data = it->get(); | |
69 std::string name; | |
70 const base::DictionaryValue* dict = nullptr; | |
71 data->arg1()->GetAsString(&name); | |
72 if (data->function_name() != "cr.webUIListenerCallback" || | |
73 !data->arg1()->GetAsString(&name) || | |
74 name != PowerHandler::kPowerManagementSettingsChangedName) { | |
75 continue; | |
76 } | |
77 if (!data->arg2()->GetAsDictionary(&dict)) { | |
78 ADD_FAILURE() << "Failed to get dict from " << name << " message"; | |
79 continue; | |
80 } | |
81 std::string out; | |
82 EXPECT_TRUE(base::JSONWriter::Write(*dict, &out)); | |
83 return out; | |
84 } | |
85 | |
86 ADD_FAILURE() << PowerHandler::kPowerManagementSettingsChangedName | |
87 << " message was not sent"; | |
88 return std::string(); | |
89 } | |
90 | |
91 // Returns a string for the given settings that can be compared against the | |
92 // output of GetLastSettingsChangedMessage(). | |
93 std::string CreateSettingsChangedString( | |
94 PowerHandler::IdleBehavior idle_behavior, | |
95 bool idle_managed, | |
96 PowerPolicyController::Action lid_closed_behavior, | |
97 bool lid_closed_managed, | |
98 bool has_lid) { | |
99 base::DictionaryValue dict; | |
100 dict.SetInteger(PowerHandler::kIdleBehaviorKey, | |
101 static_cast<int>(idle_behavior)); | |
102 dict.SetBoolean(PowerHandler::kIdleManagedKey, idle_managed); | |
103 dict.SetInteger(PowerHandler::kLidClosedBehaviorKey, lid_closed_behavior); | |
104 dict.SetBoolean(PowerHandler::kLidClosedManagedKey, lid_closed_managed); | |
105 dict.SetBoolean(PowerHandler::kHasLidKey, has_lid); | |
106 | |
107 std::string out; | |
108 EXPECT_TRUE(base::JSONWriter::Write(dict, &out)); | |
109 return out; | |
110 } | |
111 | |
112 // Returns the user-set value of the integer pref identified by |name| or -1 | |
113 // if the pref is unset. | |
114 int GetIntPref(const std::string& name) { | |
115 const base::Value* value = prefs_.GetUserPref(name); | |
116 return value ? value->GetInt() : -1; | |
117 } | |
118 | |
119 base::test::ScopedTaskEnvironment scoped_task_environment_; | |
120 sync_preferences::TestingPrefServiceSyncable prefs_; | |
121 content::TestWebUI web_ui_; | |
122 | |
123 // Owned by chromeos::DBusThreadManager. | |
124 chromeos::FakePowerManagerClient* power_manager_client_; | |
125 | |
126 std::unique_ptr<TestPowerHandler> handler_; | |
127 std::unique_ptr<TestPowerHandler::TestAPI> test_api_; | |
128 | |
129 private: | |
130 DISALLOW_COPY_AND_ASSIGN(PowerHandlerTest); | |
131 }; | |
132 | |
133 // Verifies that settings are sent to WebUI when requested. | |
134 TEST_F(PowerHandlerTest, SendInitialSettings) { | |
135 test_api_->RequestPowerManagementSettings(); | |
136 EXPECT_EQ(CreateSettingsChangedString( | |
137 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
138 false /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
139 false /* lid_closed_managed */, true /* has_lid */), | |
140 GetLastSettingsChangedMessage()); | |
141 } | |
142 | |
143 // Verifies that WebUI receives updated settings when the lid state changes. | |
144 TEST_F(PowerHandlerTest, SendSettingsForLidStateChanges) { | |
145 power_manager_client_->SetLidState(PowerManagerClient::LidState::NOT_PRESENT, | |
146 base::TimeTicks()); | |
147 EXPECT_EQ(CreateSettingsChangedString( | |
148 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
149 false /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
150 false /* lid_closed_managed */, false /* has_lid */), | |
151 GetLastSettingsChangedMessage()); | |
152 | |
153 power_manager_client_->SetLidState(PowerManagerClient::LidState::OPEN, | |
154 base::TimeTicks()); | |
155 EXPECT_EQ(CreateSettingsChangedString( | |
156 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
157 false /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
158 false /* lid_closed_managed */, true /* has_lid */), | |
159 GetLastSettingsChangedMessage()); | |
160 } | |
161 | |
162 // Verifies that when various prefs are managed, the corresponding settings are | |
163 // reported as managed to WebUI. | |
164 TEST_F(PowerHandlerTest, SendSettingsForManagedPrefs) { | |
165 // Making an arbitrary delay pref managed should result in the idle setting | |
166 // being reported as managed. | |
167 prefs_.SetManagedPref(prefs::kPowerAcScreenDimDelayMs, | |
168 base::MakeUnique<base::Value>(10000)); | |
169 EXPECT_EQ(CreateSettingsChangedString( | |
170 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
171 true /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
172 false /* lid_closed_managed */, true /* has_lid */), | |
173 GetLastSettingsChangedMessage()); | |
174 | |
175 // Ditto for making the lid action pref managed. | |
176 prefs_.SetManagedPref( | |
177 prefs::kPowerLidClosedAction, | |
178 base::MakeUnique<base::Value>(PowerPolicyController::ACTION_SUSPEND)); | |
179 EXPECT_EQ(CreateSettingsChangedString( | |
180 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
181 true /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
182 true /* lid_closed_managed */, true /* has_lid */), | |
183 GetLastSettingsChangedMessage()); | |
184 } | |
185 | |
186 // Verifies that idle-related prefs are distilled into the proper WebUI | |
187 // settings. | |
188 TEST_F(PowerHandlerTest, SendIdleSettingForPrefChanges) { | |
189 // Set a do-nothing idle action and a nonzero screen-off delay. | |
190 prefs_.SetUserPref( | |
191 prefs::kPowerAcIdleAction, | |
192 base::MakeUnique<base::Value>(PowerPolicyController::ACTION_DO_NOTHING)); | |
193 prefs_.SetUserPref(prefs::kPowerAcScreenOffDelayMs, | |
194 base::MakeUnique<base::Value>(10000)); | |
195 EXPECT_EQ(CreateSettingsChangedString( | |
196 PowerHandler::IdleBehavior::DISPLAY_OFF_STAY_AWAKE, | |
197 false /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
198 false /* lid_closed_managed */, true /* has_lid */), | |
199 GetLastSettingsChangedMessage()); | |
200 | |
201 // Now set the delay to zero and check that the setting goes to "display on". | |
202 prefs_.SetUserPref(prefs::kPowerAcScreenOffDelayMs, | |
203 base::MakeUnique<base::Value>(0)); | |
204 EXPECT_EQ(CreateSettingsChangedString( | |
205 PowerHandler::IdleBehavior::DISPLAY_ON, | |
206 false /* idle_managed */, PowerPolicyController::ACTION_SUSPEND, | |
207 false /* lid_closed_managed */, true /* has_lid */), | |
208 GetLastSettingsChangedMessage()); | |
209 | |
210 // Other idle actions should result in an "other" setting. | |
211 prefs_.SetUserPref(prefs::kPowerAcIdleAction, | |
212 base::MakeUnique<base::Value>( | |
213 PowerPolicyController::ACTION_STOP_SESSION)); | |
214 EXPECT_EQ(CreateSettingsChangedString( | |
215 PowerHandler::IdleBehavior::OTHER, false /* idle_managed */, | |
216 PowerPolicyController::ACTION_SUSPEND, | |
217 false /* lid_closed_managed */, true /* has_lid */), | |
218 GetLastSettingsChangedMessage()); | |
219 } | |
220 | |
221 // Verifies that the lid-closed pref's value is sent directly to WebUI. | |
222 TEST_F(PowerHandlerTest, SendLidSettingForPrefChanges) { | |
223 prefs_.SetUserPref( | |
224 prefs::kPowerLidClosedAction, | |
225 base::MakeUnique<base::Value>(PowerPolicyController::ACTION_SHUT_DOWN)); | |
226 EXPECT_EQ( | |
227 CreateSettingsChangedString( | |
228 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
229 false /* idle_managed */, PowerPolicyController::ACTION_SHUT_DOWN, | |
230 false /* lid_closed_managed */, true /* has_lid */), | |
231 GetLastSettingsChangedMessage()); | |
232 | |
233 prefs_.SetUserPref(prefs::kPowerLidClosedAction, | |
234 base::MakeUnique<base::Value>( | |
235 PowerPolicyController::ACTION_STOP_SESSION)); | |
236 EXPECT_EQ( | |
237 CreateSettingsChangedString( | |
238 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP, | |
239 false /* idle_managed */, PowerPolicyController::ACTION_STOP_SESSION, | |
240 false /* lid_closed_managed */, true /* has_lid */), | |
241 GetLastSettingsChangedMessage()); | |
242 } | |
243 | |
244 // Verifies that requests from WebUI to update the idle behavior update prefs | |
245 // appropriately. | |
246 TEST_F(PowerHandlerTest, SetIdleBehavior) { | |
247 // Request the "display on" setting and check that prefs are set | |
248 // appropriately. | |
249 test_api_->SetIdleBehavior(PowerHandler::IdleBehavior::DISPLAY_ON); | |
250 EXPECT_EQ(PowerPolicyController::ACTION_DO_NOTHING, | |
251 GetIntPref(prefs::kPowerAcIdleAction)); | |
252 EXPECT_EQ(0, GetIntPref(prefs::kPowerAcScreenDimDelayMs)); | |
253 EXPECT_EQ(0, GetIntPref(prefs::kPowerAcScreenOffDelayMs)); | |
254 EXPECT_EQ(0, GetIntPref(prefs::kPowerAcScreenLockDelayMs)); | |
255 EXPECT_EQ(PowerPolicyController::ACTION_DO_NOTHING, | |
256 GetIntPref(prefs::kPowerBatteryIdleAction)); | |
257 EXPECT_EQ(0, GetIntPref(prefs::kPowerBatteryScreenDimDelayMs)); | |
258 EXPECT_EQ(0, GetIntPref(prefs::kPowerBatteryScreenOffDelayMs)); | |
259 EXPECT_EQ(0, GetIntPref(prefs::kPowerBatteryScreenLockDelayMs)); | |
260 | |
261 // "Turn the display off but stay awake" should set the idle prefs but clear | |
262 // the screen delays. | |
263 test_api_->SetIdleBehavior( | |
264 PowerHandler::IdleBehavior::DISPLAY_OFF_STAY_AWAKE); | |
265 EXPECT_EQ(PowerPolicyController::ACTION_DO_NOTHING, | |
266 GetIntPref(prefs::kPowerAcIdleAction)); | |
267 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenDimDelayMs)); | |
268 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenOffDelayMs)); | |
269 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenLockDelayMs)); | |
270 EXPECT_EQ(PowerPolicyController::ACTION_DO_NOTHING, | |
271 GetIntPref(prefs::kPowerBatteryIdleAction)); | |
272 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenDimDelayMs)); | |
273 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenOffDelayMs)); | |
274 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenLockDelayMs)); | |
275 | |
276 // Now switch to the "display on" setting (to set the prefs again) and check | |
277 // that the "sleep" setting clears all the prefs. | |
278 test_api_->SetIdleBehavior(PowerHandler::IdleBehavior::DISPLAY_ON); | |
279 test_api_->SetIdleBehavior(PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP); | |
280 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcIdleAction)); | |
281 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenDimDelayMs)); | |
282 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenOffDelayMs)); | |
283 EXPECT_EQ(-1, GetIntPref(prefs::kPowerAcScreenLockDelayMs)); | |
284 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryIdleAction)); | |
285 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenDimDelayMs)); | |
286 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenOffDelayMs)); | |
287 EXPECT_EQ(-1, GetIntPref(prefs::kPowerBatteryScreenLockDelayMs)); | |
288 } | |
289 | |
290 // Verifies that requests from WebUI to change the lid behavior update the pref. | |
291 TEST_F(PowerHandlerTest, SetLidBehavior) { | |
292 // The "do nothing" setting should update the pref. | |
293 test_api_->SetLidClosedBehavior(PowerPolicyController::ACTION_DO_NOTHING); | |
294 EXPECT_EQ(PowerPolicyController::ACTION_DO_NOTHING, | |
295 GetIntPref(prefs::kPowerLidClosedAction)); | |
296 | |
297 // Selecting the "suspend" setting should just clear the pref. | |
298 test_api_->SetLidClosedBehavior(PowerPolicyController::ACTION_SUSPEND); | |
299 EXPECT_EQ(-1, GetIntPref(prefs::kPowerLidClosedAction)); | |
300 } | |
301 | |
302 } // namespace settings | |
303 } // namespace chromeos | |
OLD | NEW |