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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 installed_[i] = false; | 185 installed_[i] = false; |
186 break; | 186 break; |
187 } | 187 } |
188 } | 188 } |
189 prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false); | 189 prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false); |
190 } | 190 } |
191 | 191 |
192 class ControlledPrefsInstallOneExtension | 192 class ControlledPrefsInstallOneExtension |
193 : public ExtensionControlledPrefsTest { | 193 : public ExtensionControlledPrefsTest { |
194 void Initialize() override { | 194 void Initialize() override { |
195 InstallExtensionControlledPref(extension1(), | 195 InstallExtensionControlledPref(extension1(), kPref1, |
196 kPref1, | 196 new base::Value("val1")); |
197 new base::StringValue("val1")); | |
198 } | 197 } |
199 void Verify() override { | 198 void Verify() override { |
200 std::string actual = prefs()->pref_service()->GetString(kPref1); | 199 std::string actual = prefs()->pref_service()->GetString(kPref1); |
201 EXPECT_EQ("val1", actual); | 200 EXPECT_EQ("val1", actual); |
202 } | 201 } |
203 }; | 202 }; |
204 TEST_F(ControlledPrefsInstallOneExtension, | 203 TEST_F(ControlledPrefsInstallOneExtension, |
205 ControlledPrefsInstallOneExtension) { } | 204 ControlledPrefsInstallOneExtension) { } |
206 | 205 |
207 // Check that we do not forget persistent incognito values after a reload. | 206 // Check that we do not forget persistent incognito values after a reload. |
208 class ControlledPrefsInstallIncognitoPersistent | 207 class ControlledPrefsInstallIncognitoPersistent |
209 : public ExtensionControlledPrefsTest { | 208 : public ExtensionControlledPrefsTest { |
210 public: | 209 public: |
211 void Initialize() override { | 210 void Initialize() override { |
212 InstallExtensionControlledPref( | 211 InstallExtensionControlledPref(extension1(), kPref1, |
213 extension1(), kPref1, new base::StringValue("val1")); | 212 new base::Value("val1")); |
214 InstallExtensionControlledPrefIncognito( | 213 InstallExtensionControlledPrefIncognito(extension1(), kPref1, |
215 extension1(), kPref1, new base::StringValue("val2")); | 214 new base::Value("val2")); |
216 std::unique_ptr<PrefService> incog_prefs( | 215 std::unique_ptr<PrefService> incog_prefs( |
217 prefs_.CreateIncognitoPrefService()); | 216 prefs_.CreateIncognitoPrefService()); |
218 std::string actual = incog_prefs->GetString(kPref1); | 217 std::string actual = incog_prefs->GetString(kPref1); |
219 EXPECT_EQ("val2", actual); | 218 EXPECT_EQ("val2", actual); |
220 } | 219 } |
221 | 220 |
222 void Verify() override { | 221 void Verify() override { |
223 // Main pref service shall see only non-incognito settings. | 222 // Main pref service shall see only non-incognito settings. |
224 std::string actual = prefs()->pref_service()->GetString(kPref1); | 223 std::string actual = prefs()->pref_service()->GetString(kPref1); |
225 EXPECT_EQ("val1", actual); | 224 EXPECT_EQ("val1", actual); |
226 // Incognito pref service shall see incognito values. | 225 // Incognito pref service shall see incognito values. |
227 std::unique_ptr<PrefService> incog_prefs( | 226 std::unique_ptr<PrefService> incog_prefs( |
228 prefs_.CreateIncognitoPrefService()); | 227 prefs_.CreateIncognitoPrefService()); |
229 actual = incog_prefs->GetString(kPref1); | 228 actual = incog_prefs->GetString(kPref1); |
230 EXPECT_EQ("val2", actual); | 229 EXPECT_EQ("val2", actual); |
231 } | 230 } |
232 }; | 231 }; |
233 TEST_F(ControlledPrefsInstallIncognitoPersistent, | 232 TEST_F(ControlledPrefsInstallIncognitoPersistent, |
234 ControlledPrefsInstallIncognitoPersistent) { } | 233 ControlledPrefsInstallIncognitoPersistent) { } |
235 | 234 |
236 // Check that we forget 'session only' incognito values after a reload. | 235 // Check that we forget 'session only' incognito values after a reload. |
237 class ControlledPrefsInstallIncognitoSessionOnly | 236 class ControlledPrefsInstallIncognitoSessionOnly |
238 : public ExtensionControlledPrefsTest { | 237 : public ExtensionControlledPrefsTest { |
239 public: | 238 public: |
240 ControlledPrefsInstallIncognitoSessionOnly() : iteration_(0) {} | 239 ControlledPrefsInstallIncognitoSessionOnly() : iteration_(0) {} |
241 | 240 |
242 void Initialize() override { | 241 void Initialize() override { |
243 InstallExtensionControlledPref( | 242 InstallExtensionControlledPref(extension1(), kPref1, |
244 extension1(), kPref1, new base::StringValue("val1")); | 243 new base::Value("val1")); |
245 InstallExtensionControlledPrefIncognitoSessionOnly( | 244 InstallExtensionControlledPrefIncognitoSessionOnly(extension1(), kPref1, |
246 extension1(), kPref1, new base::StringValue("val2")); | 245 new base::Value("val2")); |
247 std::unique_ptr<PrefService> incog_prefs( | 246 std::unique_ptr<PrefService> incog_prefs( |
248 prefs_.CreateIncognitoPrefService()); | 247 prefs_.CreateIncognitoPrefService()); |
249 std::string actual = incog_prefs->GetString(kPref1); | 248 std::string actual = incog_prefs->GetString(kPref1); |
250 EXPECT_EQ("val2", actual); | 249 EXPECT_EQ("val2", actual); |
251 } | 250 } |
252 void Verify() override { | 251 void Verify() override { |
253 // Main pref service shall see only non-incognito settings. | 252 // Main pref service shall see only non-incognito settings. |
254 std::string actual = prefs()->pref_service()->GetString(kPref1); | 253 std::string actual = prefs()->pref_service()->GetString(kPref1); |
255 EXPECT_EQ("val1", actual); | 254 EXPECT_EQ("val1", actual); |
256 // Incognito pref service shall see session-only incognito values only | 255 // Incognito pref service shall see session-only incognito values only |
257 // during first run. Once the pref service was reloaded, all values shall be | 256 // during first run. Once the pref service was reloaded, all values shall be |
258 // discarded. | 257 // discarded. |
259 std::unique_ptr<PrefService> incog_prefs( | 258 std::unique_ptr<PrefService> incog_prefs( |
260 prefs_.CreateIncognitoPrefService()); | 259 prefs_.CreateIncognitoPrefService()); |
261 actual = incog_prefs->GetString(kPref1); | 260 actual = incog_prefs->GetString(kPref1); |
262 if (iteration_ == 0) { | 261 if (iteration_ == 0) { |
263 EXPECT_EQ("val2", actual); | 262 EXPECT_EQ("val2", actual); |
264 } else { | 263 } else { |
265 EXPECT_EQ("val1", actual); | 264 EXPECT_EQ("val1", actual); |
266 } | 265 } |
267 ++iteration_; | 266 ++iteration_; |
268 } | 267 } |
269 int iteration_; | 268 int iteration_; |
270 }; | 269 }; |
271 TEST_F(ControlledPrefsInstallIncognitoSessionOnly, | 270 TEST_F(ControlledPrefsInstallIncognitoSessionOnly, |
272 ControlledPrefsInstallIncognitoSessionOnly) { } | 271 ControlledPrefsInstallIncognitoSessionOnly) { } |
273 | 272 |
274 class ControlledPrefsUninstallExtension : public ExtensionControlledPrefsTest { | 273 class ControlledPrefsUninstallExtension : public ExtensionControlledPrefsTest { |
275 void Initialize() override { | 274 void Initialize() override { |
276 InstallExtensionControlledPref( | 275 InstallExtensionControlledPref(extension1(), kPref1, |
277 extension1(), kPref1, new base::StringValue("val1")); | 276 new base::Value("val1")); |
278 InstallExtensionControlledPref( | 277 InstallExtensionControlledPref(extension1(), kPref2, |
279 extension1(), kPref2, new base::StringValue("val2")); | 278 new base::Value("val2")); |
280 scoped_refptr<ContentSettingsStore> store = content_settings_store(); | 279 scoped_refptr<ContentSettingsStore> store = content_settings_store(); |
281 ContentSettingsPattern pattern = | 280 ContentSettingsPattern pattern = |
282 ContentSettingsPattern::FromString("http://[*.]example.com"); | 281 ContentSettingsPattern::FromString("http://[*.]example.com"); |
283 store->SetExtensionContentSetting(extension1()->id(), | 282 store->SetExtensionContentSetting(extension1()->id(), |
284 pattern, pattern, | 283 pattern, pattern, |
285 CONTENT_SETTINGS_TYPE_IMAGES, | 284 CONTENT_SETTINGS_TYPE_IMAGES, |
286 std::string(), | 285 std::string(), |
287 CONTENT_SETTING_BLOCK, | 286 CONTENT_SETTING_BLOCK, |
288 kExtensionPrefsScopeRegular); | 287 kExtensionPrefsScopeRegular); |
289 | 288 |
(...skipping 28 matching lines...) Expand all Loading... |
318 std::unique_ptr<PrefService> incog_prefs( | 317 std::unique_ptr<PrefService> incog_prefs( |
319 prefs_.CreateIncognitoPrefService()); | 318 prefs_.CreateIncognitoPrefService()); |
320 PrefChangeRegistrar incognito_registrar; | 319 PrefChangeRegistrar incognito_registrar; |
321 incognito_registrar.Init(incog_prefs.get()); | 320 incognito_registrar.Init(incog_prefs.get()); |
322 incognito_registrar.Add(kPref1, incognito_observer.GetCallback()); | 321 incognito_registrar.Add(kPref1, incognito_observer.GetCallback()); |
323 | 322 |
324 // Write value and check notification. | 323 // Write value and check notification. |
325 EXPECT_CALL(observer, OnPreferenceChanged(_)); | 324 EXPECT_CALL(observer, OnPreferenceChanged(_)); |
326 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); | 325 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); |
327 InstallExtensionControlledPref(extension1(), kPref1, | 326 InstallExtensionControlledPref(extension1(), kPref1, |
328 new base::StringValue("https://www.chromium.org")); | 327 new base::Value("https://www.chromium.org")); |
329 Mock::VerifyAndClearExpectations(&observer); | 328 Mock::VerifyAndClearExpectations(&observer); |
330 Mock::VerifyAndClearExpectations(&incognito_observer); | 329 Mock::VerifyAndClearExpectations(&incognito_observer); |
331 | 330 |
332 // Write same value. | 331 // Write same value. |
333 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); | 332 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); |
334 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)).Times(0); | 333 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)).Times(0); |
335 InstallExtensionControlledPref(extension1(), kPref1, | 334 InstallExtensionControlledPref(extension1(), kPref1, |
336 new base::StringValue("https://www.chromium.org")); | 335 new base::Value("https://www.chromium.org")); |
337 Mock::VerifyAndClearExpectations(&observer); | 336 Mock::VerifyAndClearExpectations(&observer); |
338 Mock::VerifyAndClearExpectations(&incognito_observer); | 337 Mock::VerifyAndClearExpectations(&incognito_observer); |
339 | 338 |
340 // Change value. | 339 // Change value. |
341 EXPECT_CALL(observer, OnPreferenceChanged(_)); | 340 EXPECT_CALL(observer, OnPreferenceChanged(_)); |
342 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); | 341 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); |
343 InstallExtensionControlledPref(extension1(), kPref1, | 342 InstallExtensionControlledPref(extension1(), kPref1, |
344 new base::StringValue("chrome://newtab")); | 343 new base::Value("chrome://newtab")); |
345 Mock::VerifyAndClearExpectations(&observer); | 344 Mock::VerifyAndClearExpectations(&observer); |
346 Mock::VerifyAndClearExpectations(&incognito_observer); | 345 Mock::VerifyAndClearExpectations(&incognito_observer); |
347 // Change only incognito persistent value. | 346 // Change only incognito persistent value. |
348 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); | 347 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); |
349 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); | 348 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); |
350 InstallExtensionControlledPrefIncognito(extension1(), kPref1, | 349 InstallExtensionControlledPrefIncognito( |
351 new base::StringValue("chrome://newtab2")); | 350 extension1(), kPref1, new base::Value("chrome://newtab2")); |
352 Mock::VerifyAndClearExpectations(&observer); | 351 Mock::VerifyAndClearExpectations(&observer); |
353 Mock::VerifyAndClearExpectations(&incognito_observer); | 352 Mock::VerifyAndClearExpectations(&incognito_observer); |
354 | 353 |
355 // Change only incognito session-only value. | 354 // Change only incognito session-only value. |
356 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); | 355 EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0); |
357 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); | 356 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); |
358 InstallExtensionControlledPrefIncognito(extension1(), kPref1, | 357 InstallExtensionControlledPrefIncognito( |
359 new base::StringValue("chrome://newtab3")); | 358 extension1(), kPref1, new base::Value("chrome://newtab3")); |
360 Mock::VerifyAndClearExpectations(&observer); | 359 Mock::VerifyAndClearExpectations(&observer); |
361 Mock::VerifyAndClearExpectations(&incognito_observer); | 360 Mock::VerifyAndClearExpectations(&incognito_observer); |
362 | 361 |
363 // Uninstall. | 362 // Uninstall. |
364 EXPECT_CALL(observer, OnPreferenceChanged(_)); | 363 EXPECT_CALL(observer, OnPreferenceChanged(_)); |
365 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); | 364 EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)); |
366 UninstallExtension(extension1()->id()); | 365 UninstallExtension(extension1()->id()); |
367 Mock::VerifyAndClearExpectations(&observer); | 366 Mock::VerifyAndClearExpectations(&observer); |
368 Mock::VerifyAndClearExpectations(&incognito_observer); | 367 Mock::VerifyAndClearExpectations(&incognito_observer); |
369 | 368 |
370 registrar.Remove(kPref1); | 369 registrar.Remove(kPref1); |
371 incognito_registrar.Remove(kPref1); | 370 incognito_registrar.Remove(kPref1); |
372 } | 371 } |
373 void Verify() override { | 372 void Verify() override { |
374 std::string actual = prefs()->pref_service()->GetString(kPref1); | 373 std::string actual = prefs()->pref_service()->GetString(kPref1); |
375 EXPECT_EQ(kDefaultPref1, actual); | 374 EXPECT_EQ(kDefaultPref1, actual); |
376 } | 375 } |
377 }; | 376 }; |
378 TEST_F(ControlledPrefsNotifyWhenNeeded, | 377 TEST_F(ControlledPrefsNotifyWhenNeeded, |
379 ControlledPrefsNotifyWhenNeeded) { } | 378 ControlledPrefsNotifyWhenNeeded) { } |
380 | 379 |
381 // Tests disabling an extension. | 380 // Tests disabling an extension. |
382 class ControlledPrefsDisableExtension : public ExtensionControlledPrefsTest { | 381 class ControlledPrefsDisableExtension : public ExtensionControlledPrefsTest { |
383 void Initialize() override { | 382 void Initialize() override { |
384 InstallExtensionControlledPref( | 383 InstallExtensionControlledPref(extension1(), kPref1, |
385 extension1(), kPref1, new base::StringValue("val1")); | 384 new base::Value("val1")); |
386 std::string actual = prefs()->pref_service()->GetString(kPref1); | 385 std::string actual = prefs()->pref_service()->GetString(kPref1); |
387 EXPECT_EQ("val1", actual); | 386 EXPECT_EQ("val1", actual); |
388 prefs()->SetExtensionDisabled(extension1()->id(), | 387 prefs()->SetExtensionDisabled(extension1()->id(), |
389 Extension::DISABLE_USER_ACTION); | 388 Extension::DISABLE_USER_ACTION); |
390 } | 389 } |
391 void Verify() override { | 390 void Verify() override { |
392 std::string actual = prefs()->pref_service()->GetString(kPref1); | 391 std::string actual = prefs()->pref_service()->GetString(kPref1); |
393 EXPECT_EQ(kDefaultPref1, actual); | 392 EXPECT_EQ(kDefaultPref1, actual); |
394 } | 393 } |
395 }; | 394 }; |
396 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsDisableExtension) { } | 395 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsDisableExtension) { } |
397 | 396 |
398 // Tests disabling and reenabling an extension. | 397 // Tests disabling and reenabling an extension. |
399 class ControlledPrefsReenableExtension : public ExtensionControlledPrefsTest { | 398 class ControlledPrefsReenableExtension : public ExtensionControlledPrefsTest { |
400 void Initialize() override { | 399 void Initialize() override { |
401 InstallExtensionControlledPref( | 400 InstallExtensionControlledPref(extension1(), kPref1, |
402 extension1(), kPref1, new base::StringValue("val1")); | 401 new base::Value("val1")); |
403 prefs()->SetExtensionDisabled(extension1()->id(), | 402 prefs()->SetExtensionDisabled(extension1()->id(), |
404 Extension::DISABLE_USER_ACTION); | 403 Extension::DISABLE_USER_ACTION); |
405 prefs()->SetExtensionEnabled(extension1()->id()); | 404 prefs()->SetExtensionEnabled(extension1()->id()); |
406 } | 405 } |
407 void Verify() override { | 406 void Verify() override { |
408 std::string actual = prefs()->pref_service()->GetString(kPref1); | 407 std::string actual = prefs()->pref_service()->GetString(kPref1); |
409 EXPECT_EQ("val1", actual); | 408 EXPECT_EQ("val1", actual); |
410 } | 409 } |
411 }; | 410 }; |
412 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsReenableExtension) { } | 411 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsReenableExtension) { } |
413 | 412 |
414 class ControlledPrefsSetExtensionControlledPref | 413 class ControlledPrefsSetExtensionControlledPref |
415 : public ExtensionControlledPrefsTest { | 414 : public ExtensionControlledPrefsTest { |
416 public: | 415 public: |
417 void Initialize() override { | 416 void Initialize() override { |
418 base::StringValue* v1 = new base::StringValue("https://www.chromium.org"); | 417 base::Value* v1 = new base::Value("https://www.chromium.org"); |
419 base::StringValue* v2 = new base::StringValue("https://www.chromium.org"); | 418 base::Value* v2 = new base::Value("https://www.chromium.org"); |
420 base::StringValue* v1i = new base::StringValue("https://www.chromium.org"); | 419 base::Value* v1i = new base::Value("https://www.chromium.org"); |
421 base::StringValue* v2i = new base::StringValue("https://www.chromium.org"); | 420 base::Value* v2i = new base::Value("https://www.chromium.org"); |
422 // Ownership is taken, value shall not be deleted. | 421 // Ownership is taken, value shall not be deleted. |
423 InstallExtensionControlledPref(extension1(), kPref1, v1); | 422 InstallExtensionControlledPref(extension1(), kPref1, v1); |
424 InstallExtensionControlledPrefIncognito(extension1(), kPref1, v1i); | 423 InstallExtensionControlledPrefIncognito(extension1(), kPref1, v1i); |
425 // Make sure there is no memory leak and both values are deleted. | 424 // Make sure there is no memory leak and both values are deleted. |
426 InstallExtensionControlledPref(extension1(), kPref1, v2); | 425 InstallExtensionControlledPref(extension1(), kPref1, v2); |
427 InstallExtensionControlledPrefIncognito(extension1(), kPref1, v2i); | 426 InstallExtensionControlledPrefIncognito(extension1(), kPref1, v2i); |
428 prefs_.RecreateExtensionPrefs(); | 427 prefs_.RecreateExtensionPrefs(); |
429 } | 428 } |
430 | 429 |
431 void Verify() override {} | 430 void Verify() override {} |
432 }; | 431 }; |
433 TEST_F(ControlledPrefsSetExtensionControlledPref, | 432 TEST_F(ControlledPrefsSetExtensionControlledPref, |
434 ControlledPrefsSetExtensionControlledPref) { } | 433 ControlledPrefsSetExtensionControlledPref) { } |
435 | 434 |
436 // Tests that the switches::kDisableExtensions command-line flag prevents | 435 // Tests that the switches::kDisableExtensions command-line flag prevents |
437 // extension controlled preferences from being enacted. | 436 // extension controlled preferences from being enacted. |
438 class ControlledPrefsDisableExtensions : public ExtensionControlledPrefsTest { | 437 class ControlledPrefsDisableExtensions : public ExtensionControlledPrefsTest { |
439 public: | 438 public: |
440 ControlledPrefsDisableExtensions() | 439 ControlledPrefsDisableExtensions() |
441 : iteration_(0) {} | 440 : iteration_(0) {} |
442 ~ControlledPrefsDisableExtensions() override {} | 441 ~ControlledPrefsDisableExtensions() override {} |
443 void Initialize() override { | 442 void Initialize() override { |
444 InstallExtensionControlledPref( | 443 InstallExtensionControlledPref(extension1(), kPref1, |
445 extension1(), kPref1, new base::StringValue("val1")); | 444 new base::Value("val1")); |
446 // This becomes only active in the second verification phase. | 445 // This becomes only active in the second verification phase. |
447 prefs_.set_extensions_disabled(true); | 446 prefs_.set_extensions_disabled(true); |
448 } | 447 } |
449 void Verify() override { | 448 void Verify() override { |
450 std::string actual = prefs()->pref_service()->GetString(kPref1); | 449 std::string actual = prefs()->pref_service()->GetString(kPref1); |
451 if (iteration_ == 0) { | 450 if (iteration_ == 0) { |
452 EXPECT_EQ("val1", actual); | 451 EXPECT_EQ("val1", actual); |
453 ++iteration_; | 452 ++iteration_; |
454 } else { | 453 } else { |
455 EXPECT_EQ(kDefaultPref1, actual); | 454 EXPECT_EQ(kDefaultPref1, actual); |
456 } | 455 } |
457 } | 456 } |
458 | 457 |
459 private: | 458 private: |
460 int iteration_; | 459 int iteration_; |
461 }; | 460 }; |
462 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { } | 461 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { } |
463 | 462 |
464 } // namespace extensions | 463 } // namespace extensions |
OLD | NEW |