OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/policy/core/browser/proxy_policy_handler.h" | 5 #include "components/policy/core/browser/proxy_policy_handler.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
69 EXPECT_EQ(expected_proxy_bypass_list, s); | 69 EXPECT_EQ(expected_proxy_bypass_list, s); |
70 } | 70 } |
71 ProxyPrefs::ProxyMode mode; | 71 ProxyPrefs::ProxyMode mode; |
72 ASSERT_TRUE(dict.GetMode(&mode)); | 72 ASSERT_TRUE(dict.GetMode(&mode)); |
73 EXPECT_EQ(expected_proxy_mode, mode); | 73 EXPECT_EQ(expected_proxy_mode, mode); |
74 } | 74 } |
75 }; | 75 }; |
76 | 76 |
77 TEST_F(ProxyPolicyHandlerTest, ManualOptions) { | 77 TEST_F(ProxyPolicyHandlerTest, ManualOptions) { |
78 PolicyMap policy; | 78 PolicyMap policy; |
79 policy.Set(key::kProxyBypassList, | 79 policy.Set( |
80 POLICY_LEVEL_MANDATORY, | 80 key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
81 POLICY_SCOPE_USER, | 81 POLICY_SOURCE_CLOUD, |
| 82 base::WrapUnique(new base::StringValue("http://chromium.org/override")), |
| 83 nullptr); |
| 84 policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
82 POLICY_SOURCE_CLOUD, | 85 POLICY_SOURCE_CLOUD, |
83 new base::StringValue("http://chromium.org/override"), | 86 base::WrapUnique(new base::StringValue("chromium.org")), nullptr); |
84 NULL); | |
85 policy.Set(key::kProxyServer, | |
86 POLICY_LEVEL_MANDATORY, | |
87 POLICY_SCOPE_USER, | |
88 POLICY_SOURCE_CLOUD, | |
89 new base::StringValue("chromium.org"), | |
90 NULL); | |
91 policy.Set( | 87 policy.Set( |
92 key::kProxyServerMode, | 88 key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
93 POLICY_LEVEL_MANDATORY, | |
94 POLICY_SCOPE_USER, | |
95 POLICY_SOURCE_CLOUD, | 89 POLICY_SOURCE_CLOUD, |
96 new base::FundamentalValue( | 90 base::WrapUnique(new base::FundamentalValue( |
97 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE), | 91 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE)), |
98 NULL); | 92 nullptr); |
99 UpdateProviderPolicy(policy); | 93 UpdateProviderPolicy(policy); |
100 | 94 |
101 VerifyProxyPrefs("chromium.org", | 95 VerifyProxyPrefs("chromium.org", |
102 std::string(), | 96 std::string(), |
103 "http://chromium.org/override", | 97 "http://chromium.org/override", |
104 ProxyPrefs::MODE_FIXED_SERVERS); | 98 ProxyPrefs::MODE_FIXED_SERVERS); |
105 } | 99 } |
106 | 100 |
107 TEST_F(ProxyPolicyHandlerTest, ManualOptionsReversedApplyOrder) { | 101 TEST_F(ProxyPolicyHandlerTest, ManualOptionsReversedApplyOrder) { |
108 PolicyMap policy; | 102 PolicyMap policy; |
109 policy.Set( | 103 policy.Set( |
110 key::kProxyServerMode, | 104 key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
111 POLICY_LEVEL_MANDATORY, | |
112 POLICY_SCOPE_USER, | |
113 POLICY_SOURCE_CLOUD, | 105 POLICY_SOURCE_CLOUD, |
114 new base::FundamentalValue( | 106 base::WrapUnique(new base::FundamentalValue( |
115 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE), | 107 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE)), |
116 NULL); | 108 nullptr); |
117 policy.Set(key::kProxyBypassList, | 109 policy.Set( |
118 POLICY_LEVEL_MANDATORY, | 110 key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
119 POLICY_SCOPE_USER, | 111 POLICY_SOURCE_CLOUD, |
| 112 base::WrapUnique(new base::StringValue("http://chromium.org/override")), |
| 113 nullptr); |
| 114 policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
120 POLICY_SOURCE_CLOUD, | 115 POLICY_SOURCE_CLOUD, |
121 new base::StringValue("http://chromium.org/override"), | 116 base::WrapUnique(new base::StringValue("chromium.org")), nullptr); |
122 NULL); | |
123 policy.Set(key::kProxyServer, | |
124 POLICY_LEVEL_MANDATORY, | |
125 POLICY_SCOPE_USER, | |
126 POLICY_SOURCE_CLOUD, | |
127 new base::StringValue("chromium.org"), | |
128 NULL); | |
129 UpdateProviderPolicy(policy); | 117 UpdateProviderPolicy(policy); |
130 | 118 |
131 VerifyProxyPrefs("chromium.org", | 119 VerifyProxyPrefs("chromium.org", |
132 std::string(), | 120 std::string(), |
133 "http://chromium.org/override", | 121 "http://chromium.org/override", |
134 ProxyPrefs::MODE_FIXED_SERVERS); | 122 ProxyPrefs::MODE_FIXED_SERVERS); |
135 } | 123 } |
136 | 124 |
137 TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) { | 125 TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) { |
138 PolicyMap policy; | 126 PolicyMap policy; |
139 policy.Set( | 127 policy.Set( |
140 key::kProxyServerMode, | 128 key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
141 POLICY_LEVEL_MANDATORY, | |
142 POLICY_SCOPE_USER, | |
143 POLICY_SOURCE_CLOUD, | 129 POLICY_SOURCE_CLOUD, |
144 new base::FundamentalValue( | 130 base::WrapUnique(new base::FundamentalValue( |
145 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE), | 131 ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE)), |
146 NULL); | 132 nullptr); |
147 UpdateProviderPolicy(policy); | 133 UpdateProviderPolicy(policy); |
148 | 134 |
149 const base::Value* value = NULL; | 135 const base::Value* value = NULL; |
150 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); | 136 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); |
151 } | 137 } |
152 | 138 |
153 TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) { | 139 TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) { |
154 PolicyMap policy; | 140 PolicyMap policy; |
155 policy.Set(key::kProxyServerMode, | 141 policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
156 POLICY_LEVEL_MANDATORY, | 142 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue( |
157 POLICY_SCOPE_USER, | 143 ProxyPolicyHandler::PROXY_SERVER_MODE)), |
158 POLICY_SOURCE_CLOUD, | 144 nullptr); |
159 new base::FundamentalValue(ProxyPolicyHandler::PROXY_SERVER_MODE), | |
160 NULL); | |
161 UpdateProviderPolicy(policy); | 145 UpdateProviderPolicy(policy); |
162 VerifyProxyPrefs( | 146 VerifyProxyPrefs( |
163 std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT); | 147 std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT); |
164 } | 148 } |
165 | 149 |
166 TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) { | 150 TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) { |
167 PolicyMap policy; | 151 PolicyMap policy; |
168 policy.Set(key::kProxyMode, | 152 policy.Set( |
169 POLICY_LEVEL_MANDATORY, | 153 key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
170 POLICY_SCOPE_USER, | 154 POLICY_SOURCE_CLOUD, |
171 POLICY_SOURCE_CLOUD, | 155 base::WrapUnique(new base::StringValue(ProxyPrefs::kDirectProxyModeName)), |
172 new base::StringValue(ProxyPrefs::kDirectProxyModeName), | 156 nullptr); |
173 NULL); | |
174 UpdateProviderPolicy(policy); | 157 UpdateProviderPolicy(policy); |
175 VerifyProxyPrefs( | 158 VerifyProxyPrefs( |
176 std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT); | 159 std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT); |
177 } | 160 } |
178 | 161 |
179 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) { | 162 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) { |
180 PolicyMap policy; | 163 PolicyMap policy; |
181 policy.Set(key::kProxyServerMode, | 164 policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
182 POLICY_LEVEL_MANDATORY, | |
183 POLICY_SCOPE_USER, | |
184 POLICY_SOURCE_CLOUD, | 165 POLICY_SOURCE_CLOUD, |
185 new base::FundamentalValue( | 166 base::WrapUnique(new base::FundamentalValue( |
186 ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE), | 167 ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE)), |
187 NULL); | 168 nullptr); |
188 UpdateProviderPolicy(policy); | 169 UpdateProviderPolicy(policy); |
189 VerifyProxyPrefs(std::string(), | 170 VerifyProxyPrefs(std::string(), |
190 std::string(), | 171 std::string(), |
191 std::string(), | 172 std::string(), |
192 ProxyPrefs::MODE_AUTO_DETECT); | 173 ProxyPrefs::MODE_AUTO_DETECT); |
193 } | 174 } |
194 | 175 |
195 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) { | 176 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) { |
196 PolicyMap policy; | 177 PolicyMap policy; |
197 policy.Set(key::kProxyMode, | 178 policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
198 POLICY_LEVEL_MANDATORY, | 179 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::StringValue( |
199 POLICY_SCOPE_USER, | 180 ProxyPrefs::kAutoDetectProxyModeName)), |
200 POLICY_SOURCE_CLOUD, | 181 nullptr); |
201 new base::StringValue(ProxyPrefs::kAutoDetectProxyModeName), | |
202 NULL); | |
203 UpdateProviderPolicy(policy); | 182 UpdateProviderPolicy(policy); |
204 VerifyProxyPrefs(std::string(), | 183 VerifyProxyPrefs(std::string(), |
205 std::string(), | 184 std::string(), |
206 std::string(), | 185 std::string(), |
207 ProxyPrefs::MODE_AUTO_DETECT); | 186 ProxyPrefs::MODE_AUTO_DETECT); |
208 } | 187 } |
209 | 188 |
210 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyMode) { | 189 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyMode) { |
211 PolicyMap policy; | 190 PolicyMap policy; |
212 policy.Set(key::kProxyPacUrl, | 191 policy.Set( |
213 POLICY_LEVEL_MANDATORY, | 192 key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
214 POLICY_SCOPE_USER, | 193 POLICY_SOURCE_CLOUD, |
215 POLICY_SOURCE_CLOUD, | 194 base::WrapUnique(new base::StringValue("http://short.org/proxy.pac")), |
216 new base::StringValue("http://short.org/proxy.pac"), | 195 nullptr); |
217 NULL); | 196 policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
218 policy.Set(key::kProxyMode, | 197 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::StringValue( |
219 POLICY_LEVEL_MANDATORY, | 198 ProxyPrefs::kPacScriptProxyModeName)), |
220 POLICY_SCOPE_USER, | 199 nullptr); |
221 POLICY_SOURCE_CLOUD, | |
222 new base::StringValue(ProxyPrefs::kPacScriptProxyModeName), | |
223 NULL); | |
224 UpdateProviderPolicy(policy); | 200 UpdateProviderPolicy(policy); |
225 VerifyProxyPrefs(std::string(), | 201 VerifyProxyPrefs(std::string(), |
226 "http://short.org/proxy.pac", | 202 "http://short.org/proxy.pac", |
227 std::string(), | 203 std::string(), |
228 ProxyPrefs::MODE_PAC_SCRIPT); | 204 ProxyPrefs::MODE_PAC_SCRIPT); |
229 } | 205 } |
230 | 206 |
231 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) { | 207 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) { |
232 PolicyMap policy; | 208 PolicyMap policy; |
233 policy.Set(key::kProxyMode, | 209 policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
234 POLICY_LEVEL_MANDATORY, | 210 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::StringValue( |
235 POLICY_SCOPE_USER, | 211 ProxyPrefs::kPacScriptProxyModeName)), |
236 POLICY_SOURCE_CLOUD, | |
237 new base::StringValue(ProxyPrefs::kPacScriptProxyModeName), | |
238 NULL); | 212 NULL); |
239 UpdateProviderPolicy(policy); | 213 UpdateProviderPolicy(policy); |
240 const base::Value* value = NULL; | 214 const base::Value* value = NULL; |
241 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); | 215 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); |
242 } | 216 } |
243 | 217 |
244 // Regression test for http://crbug.com/78016, CPanel returns empty strings | 218 // Regression test for http://crbug.com/78016, CPanel returns empty strings |
245 // for unset properties. | 219 // for unset properties. |
246 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) { | 220 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) { |
247 PolicyMap policy; | 221 PolicyMap policy; |
248 policy.Set(key::kProxyServer, | 222 policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
249 POLICY_LEVEL_MANDATORY, | |
250 POLICY_SCOPE_USER, | |
251 POLICY_SOURCE_CLOUD, | 223 POLICY_SOURCE_CLOUD, |
252 new base::StringValue(std::string()), | 224 base::WrapUnique(new base::StringValue(std::string())), nullptr); |
253 NULL); | 225 policy.Set( |
254 policy.Set(key::kProxyPacUrl, | 226 key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
255 POLICY_LEVEL_MANDATORY, | 227 POLICY_SOURCE_CLOUD, |
256 POLICY_SCOPE_USER, | 228 base::WrapUnique(new base::StringValue("http://short.org/proxy.pac")), |
257 POLICY_SOURCE_CLOUD, | 229 nullptr); |
258 new base::StringValue("http://short.org/proxy.pac"), | 230 policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
259 NULL); | 231 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::StringValue( |
260 policy.Set(key::kProxyMode, | 232 ProxyPrefs::kPacScriptProxyModeName)), |
261 POLICY_LEVEL_MANDATORY, | 233 nullptr); |
262 POLICY_SCOPE_USER, | |
263 POLICY_SOURCE_CLOUD, | |
264 new base::StringValue(ProxyPrefs::kPacScriptProxyModeName), | |
265 NULL); | |
266 UpdateProviderPolicy(policy); | 234 UpdateProviderPolicy(policy); |
267 VerifyProxyPrefs(std::string(), | 235 VerifyProxyPrefs(std::string(), |
268 "http://short.org/proxy.pac", | 236 "http://short.org/proxy.pac", |
269 std::string(), | 237 std::string(), |
270 ProxyPrefs::MODE_PAC_SCRIPT); | 238 ProxyPrefs::MODE_PAC_SCRIPT); |
271 } | 239 } |
272 | 240 |
273 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) { | 241 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) { |
274 PolicyMap policy; | 242 PolicyMap policy; |
275 policy.Set(key::kProxyServerMode, | 243 policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
276 POLICY_LEVEL_MANDATORY, | |
277 POLICY_SCOPE_USER, | |
278 POLICY_SOURCE_CLOUD, | 244 POLICY_SOURCE_CLOUD, |
279 new base::FundamentalValue( | 245 base::WrapUnique(new base::FundamentalValue( |
280 ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE), | 246 ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE)), |
281 NULL); | 247 nullptr); |
282 UpdateProviderPolicy(policy); | 248 UpdateProviderPolicy(policy); |
283 VerifyProxyPrefs( | 249 VerifyProxyPrefs( |
284 std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM); | 250 std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM); |
285 } | 251 } |
286 | 252 |
287 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) { | 253 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) { |
288 PolicyMap policy; | 254 PolicyMap policy; |
289 policy.Set(key::kProxyMode, | 255 policy.Set( |
290 POLICY_LEVEL_MANDATORY, | 256 key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
291 POLICY_SCOPE_USER, | 257 POLICY_SOURCE_CLOUD, |
292 POLICY_SOURCE_CLOUD, | 258 base::WrapUnique(new base::StringValue(ProxyPrefs::kSystemProxyModeName)), |
293 new base::StringValue(ProxyPrefs::kSystemProxyModeName), | 259 nullptr); |
294 NULL); | |
295 UpdateProviderPolicy(policy); | 260 UpdateProviderPolicy(policy); |
296 VerifyProxyPrefs( | 261 VerifyProxyPrefs( |
297 std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM); | 262 std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM); |
298 } | 263 } |
299 | 264 |
300 TEST_F(ProxyPolicyHandlerTest, | 265 TEST_F(ProxyPolicyHandlerTest, |
301 ProxyModeOverridesProxyServerMode) { | 266 ProxyModeOverridesProxyServerMode) { |
302 PolicyMap policy; | 267 PolicyMap policy; |
303 policy.Set(key::kProxyServerMode, | 268 policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
304 POLICY_LEVEL_MANDATORY, | 269 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue( |
305 POLICY_SCOPE_USER, | 270 ProxyPolicyHandler::PROXY_SERVER_MODE)), |
306 POLICY_SOURCE_CLOUD, | 271 nullptr); |
307 new base::FundamentalValue(ProxyPolicyHandler::PROXY_SERVER_MODE), | 272 policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
308 NULL); | 273 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::StringValue( |
309 policy.Set(key::kProxyMode, | 274 ProxyPrefs::kAutoDetectProxyModeName)), |
310 POLICY_LEVEL_MANDATORY, | 275 nullptr); |
311 POLICY_SCOPE_USER, | |
312 POLICY_SOURCE_CLOUD, | |
313 new base::StringValue(ProxyPrefs::kAutoDetectProxyModeName), | |
314 NULL); | |
315 UpdateProviderPolicy(policy); | 276 UpdateProviderPolicy(policy); |
316 VerifyProxyPrefs(std::string(), | 277 VerifyProxyPrefs(std::string(), |
317 std::string(), | 278 std::string(), |
318 std::string(), | 279 std::string(), |
319 ProxyPrefs::MODE_AUTO_DETECT); | 280 ProxyPrefs::MODE_AUTO_DETECT); |
320 } | 281 } |
321 | 282 |
322 TEST_F(ProxyPolicyHandlerTest, ProxyInvalid) { | 283 TEST_F(ProxyPolicyHandlerTest, ProxyInvalid) { |
323 // No mode expects all three parameters being set. | 284 // No mode expects all three parameters being set. |
324 PolicyMap policy; | 285 PolicyMap policy; |
325 policy.Set(key::kProxyPacUrl, | 286 policy.Set( |
326 POLICY_LEVEL_MANDATORY, | 287 key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
327 POLICY_SCOPE_USER, | 288 POLICY_SOURCE_CLOUD, |
| 289 base::WrapUnique(new base::StringValue("http://short.org/proxy.pac")), |
| 290 nullptr); |
| 291 policy.Set( |
| 292 key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
| 293 POLICY_SOURCE_CLOUD, |
| 294 base::WrapUnique(new base::StringValue("http://chromium.org/override")), |
| 295 nullptr); |
| 296 policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
328 POLICY_SOURCE_CLOUD, | 297 POLICY_SOURCE_CLOUD, |
329 new base::StringValue("http://short.org/proxy.pac"), | 298 base::WrapUnique(new base::StringValue("chromium.org")), nullptr); |
330 NULL); | |
331 policy.Set(key::kProxyBypassList, | |
332 POLICY_LEVEL_MANDATORY, | |
333 POLICY_SCOPE_USER, | |
334 POLICY_SOURCE_CLOUD, | |
335 new base::StringValue("http://chromium.org/override"), | |
336 NULL); | |
337 policy.Set(key::kProxyServer, | |
338 POLICY_LEVEL_MANDATORY, | |
339 POLICY_SCOPE_USER, | |
340 POLICY_SOURCE_CLOUD, | |
341 new base::StringValue("chromium.org"), | |
342 NULL); | |
343 for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) { | 299 for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) { |
344 policy.Set(key::kProxyServerMode, | 300 policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
345 POLICY_LEVEL_MANDATORY, | |
346 POLICY_SCOPE_USER, | |
347 POLICY_SOURCE_CLOUD, | 301 POLICY_SOURCE_CLOUD, |
348 new base::FundamentalValue(i), | 302 base::WrapUnique(new base::FundamentalValue(i)), nullptr); |
349 NULL); | |
350 UpdateProviderPolicy(policy); | 303 UpdateProviderPolicy(policy); |
351 const base::Value* value = NULL; | 304 const base::Value* value = nullptr; |
352 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); | 305 EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value)); |
353 } | 306 } |
354 } | 307 } |
355 | 308 |
356 } // namespace policy | 309 } // namespace policy |
OLD | NEW |