chrome/browser/extensions/api/preference/preference_api_prefs_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/prefs/mock_pref_change_callback.h"
  10 #include "base/values.h"
  11 #include "chrome/browser/extensions/api/content_settings/content_settings_service.h"
  12 #include "chrome/browser/extensions/api/preference/preference_api.h"
  13 #include "chrome/browser/extensions/extension_prefs_unittest.h"
  14 #include "chrome/test/base/testing_profile.h"
  15 #include "components/pref_registry/pref_registry_syncable.h"
  16 #include "extensions/browser/extension_prefs.h"
  17 #include "extensions/common/extension.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using base::Value;
  21
  22 namespace extensions {
  23
  24 namespace {
  25
  26 const char kPref1[] = "path1.subpath";
  27 const char kPref2[] = "path2";
  28 const char kPref3[] = "path3";
  29 const char kPref4[] = "path4";
  30
  31 // Default values in case an extension pref value is not overridden.
  32 const char kDefaultPref1[] = "default pref 1";
  33 const char kDefaultPref2[] = "default pref 2";
  34 const char kDefaultPref3[] = "default pref 3";
  35 const char kDefaultPref4[] = "default pref 4";
  36
  37 }  // namespace
  38
  39 // An implementation of the PreferenceAPI which returns the ExtensionPrefs and
  40 // ExtensionPrefValueMap from the TestExtensionPrefs, rather than from a
  41 // profile (which we don't create in unittests).
  42 class TestPreferenceAPI : public PreferenceAPIBase {
  43  public:
  44   explicit TestPreferenceAPI(TestExtensionPrefs* test_extension_prefs,
  45                              ContentSettingsService* content_settings)
  46       : test_extension_prefs_(test_extension_prefs),
  47         content_settings_(content_settings) {}
  48   ~TestPreferenceAPI() {}
  49
  50  private:
  51   // PreferenceAPIBase implementation.
  52   ExtensionPrefs* extension_prefs() override {
  53     return test_extension_prefs_->prefs();
  54   }
  55   ExtensionPrefValueMap* extension_pref_value_map() override {
  56     return test_extension_prefs_->extension_pref_value_map();
  57   }
  58   scoped_refptr<ContentSettingsStore> content_settings_store() override {
  59     return content_settings_->content_settings_store();
  60   }
  61
  62   TestExtensionPrefs* test_extension_prefs_;
  63   ContentSettingsService* content_settings_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(TestPreferenceAPI);
  66 };
  67
  68 class ExtensionControlledPrefsTest : public PrefsPrepopulatedTestBase {
  69  public:
  70   ExtensionControlledPrefsTest();
  71   ~ExtensionControlledPrefsTest() override;
  72
  73   void RegisterPreferences(user_prefs::PrefRegistrySyncable* registry) override;
  74   void InstallExtensionControlledPref(Extension* extension,
  75                                       const std::string& key,
  76                                       base::Value* value);
  77   void InstallExtensionControlledPrefIncognito(Extension* extension,
  78                                                const std::string& key,
  79                                                base::Value* value);
  80   void InstallExtensionControlledPrefIncognitoSessionOnly(
  81       Extension* extension,
  82       const std::string& key,
  83       base::Value* value);
  84   void InstallExtension(Extension* extension);
  85   void UninstallExtension(const std::string& extension_id);
  86
  87   scoped_refptr<ContentSettingsStore> content_settings_store() {
  88     return content_settings_->content_settings_store();
  89   }
  90
  91  protected:
  92   void EnsureExtensionInstalled(Extension* extension);
  93   void EnsureExtensionUninstalled(const std::string& extension_id);
  94
  95   TestingProfile profile_;
  96   ContentSettingsService* content_settings_;
  97   TestPreferenceAPI test_preference_api_;
  98 };
  99
 100 ExtensionControlledPrefsTest::ExtensionControlledPrefsTest()
 101     : PrefsPrepopulatedTestBase(),
 102       content_settings_(ContentSettingsService::Get(&profile_)),
 103       test_preference_api_(&prefs_, content_settings_) {
 104   prefs_.prefs()->AddObserver(content_settings_);
 105 }
 106
 107 ExtensionControlledPrefsTest::~ExtensionControlledPrefsTest() {
 108 }
 109
 110 void ExtensionControlledPrefsTest::RegisterPreferences(
 111     user_prefs::PrefRegistrySyncable* registry) {
 112   registry->RegisterStringPref(kPref1, kDefaultPref1);
 113   registry->RegisterStringPref(kPref2, kDefaultPref2);
 114   registry->RegisterStringPref(kPref3, kDefaultPref3);
 115   registry->RegisterStringPref(kPref4, kDefaultPref4);
 116 }
 117
 118 void ExtensionControlledPrefsTest::InstallExtensionControlledPref(
 119     Extension* extension,
 120     const std::string& key,
 121     base::Value* value) {
 122   EnsureExtensionInstalled(extension);
 123   test_preference_api_.SetExtensionControlledPref(
 124       extension->id(), key, kExtensionPrefsScopeRegular, value);
 125 }
 126
 127 void ExtensionControlledPrefsTest::InstallExtensionControlledPrefIncognito(
 128     Extension* extension,
 129     const std::string& key,
 130     base::Value* value) {
 131   EnsureExtensionInstalled(extension);
 132   test_preference_api_.SetExtensionControlledPref(
 133       extension->id(), key, kExtensionPrefsScopeIncognitoPersistent, value);
 134 }
 135
 136 void ExtensionControlledPrefsTest::
 137 InstallExtensionControlledPrefIncognitoSessionOnly(Extension* extension,
 138                                                    const std::string& key,
 139                                                    base::Value* value) {
 140   EnsureExtensionInstalled(extension);
 141   test_preference_api_.SetExtensionControlledPref(
 142       extension->id(), key, kExtensionPrefsScopeIncognitoSessionOnly, value);
 143 }
 144
 145 void ExtensionControlledPrefsTest::InstallExtension(Extension* extension) {
 146   EnsureExtensionInstalled(extension);
 147 }
 148
 149 void ExtensionControlledPrefsTest::UninstallExtension(
 150     const std::string& extension_id) {
 151   EnsureExtensionUninstalled(extension_id);
 152 }
 153
 154 void ExtensionControlledPrefsTest::EnsureExtensionInstalled(
 155     Extension* extension) {
 156   // Install extension the first time a preference is set for it.
 157   Extension* extensions[] = { extension1(),
 158                               extension2(),
 159                               extension3(),
 160                               extension4() };
 161   for (size_t i = 0; i < kNumInstalledExtensions; ++i) {
 162     if (extension == extensions[i] && !installed_[i]) {
 163       prefs()->OnExtensionInstalled(extension,
 164                                     Extension::ENABLED,
 165                                     syncer::StringOrdinal(),
 166                                     std::string());
 167       prefs()->SetIsIncognitoEnabled(extension->id(), true);
 168       installed_[i] = true;
 169       break;
 170     }
 171   }
 172 }
 173
 174 void ExtensionControlledPrefsTest::EnsureExtensionUninstalled(
 175     const std::string& extension_id) {
 176   Extension* extensions[] = { extension1(),
 177                               extension2(),
 178                               extension3(),
 179                               extension4() };
 180   for (size_t i = 0; i < kNumInstalledExtensions; ++i) {
 181     if (extensions[i]->id() == extension_id) {
 182       installed_[i] = false;
 183       break;
 184     }
 185   }
 186   prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false);
 187 }
 188
 189 class ControlledPrefsInstallOneExtension
 190     : public ExtensionControlledPrefsTest {
 191   void Initialize() override {
 192     InstallExtensionControlledPref(extension1(),
 193                                    kPref1,
 194                                    new base::StringValue("val1"));
 195   }
 196   void Verify() override {
 197     std::string actual = prefs()->pref_service()->GetString(kPref1);
 198     EXPECT_EQ("val1", actual);
 199   }
 200 };
 201 TEST_F(ControlledPrefsInstallOneExtension,
 202        ControlledPrefsInstallOneExtension) { }
 203
 204 // Check that we do not forget persistent incognito values after a reload.
 205 class ControlledPrefsInstallIncognitoPersistent
 206     : public ExtensionControlledPrefsTest {
 207  public:
 208   void Initialize() override {
 209     InstallExtensionControlledPref(
 210         extension1(), kPref1, new base::StringValue("val1"));
 211     InstallExtensionControlledPrefIncognito(
 212         extension1(), kPref1, new base::StringValue("val2"));
 213     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
 214     std::string actual = incog_prefs->GetString(kPref1);
 215     EXPECT_EQ("val2", actual);
 216   }
 217
 218   void Verify() override {
 219     // Main pref service shall see only non-incognito settings.
 220     std::string actual = prefs()->pref_service()->GetString(kPref1);
 221     EXPECT_EQ("val1", actual);
 222     // Incognito pref service shall see incognito values.
 223     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
 224     actual = incog_prefs->GetString(kPref1);
 225     EXPECT_EQ("val2", actual);
 226   }
 227 };
 228 TEST_F(ControlledPrefsInstallIncognitoPersistent,
 229        ControlledPrefsInstallIncognitoPersistent) { }
 230
 231 // Check that we forget 'session only' incognito values after a reload.
 232 class ControlledPrefsInstallIncognitoSessionOnly
 233     : public ExtensionControlledPrefsTest {
 234  public:
 235   ControlledPrefsInstallIncognitoSessionOnly() : iteration_(0) {}
 236
 237   void Initialize() override {
 238     InstallExtensionControlledPref(
 239         extension1(), kPref1, new base::StringValue("val1"));
 240     InstallExtensionControlledPrefIncognitoSessionOnly(
 241         extension1(), kPref1, new base::StringValue("val2"));
 242     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
 243     std::string actual = incog_prefs->GetString(kPref1);
 244     EXPECT_EQ("val2", actual);
 245   }
 246   void Verify() override {
 247     // Main pref service shall see only non-incognito settings.
 248     std::string actual = prefs()->pref_service()->GetString(kPref1);
 249     EXPECT_EQ("val1", actual);
 250     // Incognito pref service shall see session-only incognito values only
 251     // during first run. Once the pref service was reloaded, all values shall be
 252     // discarded.
 253     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
 254     actual = incog_prefs->GetString(kPref1);
 255     if (iteration_ == 0) {
 256       EXPECT_EQ("val2", actual);
 257     } else {
 258       EXPECT_EQ("val1", actual);
 259     }
 260     ++iteration_;
 261   }
 262   int iteration_;
 263 };
 264 TEST_F(ControlledPrefsInstallIncognitoSessionOnly,
 265        ControlledPrefsInstallIncognitoSessionOnly) { }
 266
 267 class ControlledPrefsUninstallExtension : public ExtensionControlledPrefsTest {
 268   void Initialize() override {
 269     InstallExtensionControlledPref(
 270         extension1(), kPref1, new base::StringValue("val1"));
 271     InstallExtensionControlledPref(
 272         extension1(), kPref2, new base::StringValue("val2"));
 273     scoped_refptr<ContentSettingsStore> store = content_settings_store();
 274     ContentSettingsPattern pattern =
 275         ContentSettingsPattern::FromString("http://[*.]example.com");
 276     store->SetExtensionContentSetting(extension1()->id(),
 277                                       pattern, pattern,
 278                                       CONTENT_SETTINGS_TYPE_IMAGES,
 279                                       std::string(),
 280                                       CONTENT_SETTING_BLOCK,
 281                                       kExtensionPrefsScopeRegular);
 282
 283     UninstallExtension(extension1()->id());
 284   }
 285   void Verify() override {
 286     EXPECT_FALSE(prefs()->HasPrefForExtension(extension1()->id()));
 287
 288     std::string actual;
 289     actual = prefs()->pref_service()->GetString(kPref1);
 290     EXPECT_EQ(kDefaultPref1, actual);
 291     actual = prefs()->pref_service()->GetString(kPref2);
 292     EXPECT_EQ(kDefaultPref2, actual);
 293   }
 294 };
 295 TEST_F(ControlledPrefsUninstallExtension,
 296        ControlledPrefsUninstallExtension) { }
 297
 298 // Tests triggering of notifications to registered observers.
 299 class ControlledPrefsNotifyWhenNeeded : public ExtensionControlledPrefsTest {
 300   void Initialize() override {
 301     using testing::_;
 302     using testing::Mock;
 303     using testing::StrEq;
 304
 305     MockPrefChangeCallback observer(prefs()->pref_service());
 306     PrefChangeRegistrar registrar;
 307     registrar.Init(prefs()->pref_service());
 308     registrar.Add(kPref1, observer.GetCallback());
 309
 310     MockPrefChangeCallback incognito_observer(prefs()->pref_service());
 311     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
 312     PrefChangeRegistrar incognito_registrar;
 313     incognito_registrar.Init(incog_prefs.get());
 314     incognito_registrar.Add(kPref1, incognito_observer.GetCallback());
 315
 316     // Write value and check notification.
 317     EXPECT_CALL(observer, OnPreferenceChanged(_));
 318     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
 319     InstallExtensionControlledPref(extension1(), kPref1,
 320         new base::StringValue("https://www.chromium.org"));
 321     Mock::VerifyAndClearExpectations(&observer);
 322     Mock::VerifyAndClearExpectations(&incognito_observer);
 323
 324     // Write same value.
 325     EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0);
 326     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_)).Times(0);
 327     InstallExtensionControlledPref(extension1(), kPref1,
 328         new base::StringValue("https://www.chromium.org"));
 329     Mock::VerifyAndClearExpectations(&observer);
 330     Mock::VerifyAndClearExpectations(&incognito_observer);
 331
 332     // Change value.
 333     EXPECT_CALL(observer, OnPreferenceChanged(_));
 334     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
 335     InstallExtensionControlledPref(extension1(), kPref1,
 336         new base::StringValue("chrome://newtab"));
 337     Mock::VerifyAndClearExpectations(&observer);
 338     Mock::VerifyAndClearExpectations(&incognito_observer);
 339     // Change only incognito persistent value.
 340     EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0);
 341     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
 342     InstallExtensionControlledPrefIncognito(extension1(), kPref1,
 343         new base::StringValue("chrome://newtab2"));
 344     Mock::VerifyAndClearExpectations(&observer);
 345     Mock::VerifyAndClearExpectations(&incognito_observer);
 346
 347     // Change only incognito session-only value.
 348     EXPECT_CALL(observer, OnPreferenceChanged(_)).Times(0);
 349     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
 350     InstallExtensionControlledPrefIncognito(extension1(), kPref1,
 351         new base::StringValue("chrome://newtab3"));
 352     Mock::VerifyAndClearExpectations(&observer);
 353     Mock::VerifyAndClearExpectations(&incognito_observer);
 354
 355     // Uninstall.
 356     EXPECT_CALL(observer, OnPreferenceChanged(_));
 357     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
 358     UninstallExtension(extension1()->id());
 359     Mock::VerifyAndClearExpectations(&observer);
 360     Mock::VerifyAndClearExpectations(&incognito_observer);
 361
 362     registrar.Remove(kPref1);
 363     incognito_registrar.Remove(kPref1);
 364   }
 365   void Verify() override {
 366     std::string actual = prefs()->pref_service()->GetString(kPref1);
 367     EXPECT_EQ(kDefaultPref1, actual);
 368   }
 369 };
 370 TEST_F(ControlledPrefsNotifyWhenNeeded,
 371        ControlledPrefsNotifyWhenNeeded) { }
 372
 373 // Tests disabling an extension.
 374 class ControlledPrefsDisableExtension : public ExtensionControlledPrefsTest {
 375   void Initialize() override {
 376     InstallExtensionControlledPref(
 377         extension1(), kPref1, new base::StringValue("val1"));
 378     std::string actual = prefs()->pref_service()->GetString(kPref1);
 379     EXPECT_EQ("val1", actual);
 380     prefs()->SetExtensionDisabled(extension1()->id(),
 381                                   Extension::DISABLE_USER_ACTION);
 382   }
 383   void Verify() override {
 384     std::string actual = prefs()->pref_service()->GetString(kPref1);
 385     EXPECT_EQ(kDefaultPref1, actual);
 386   }
 387 };
 388 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsDisableExtension) { }
 389
 390 // Tests disabling and reenabling an extension.
 391 class ControlledPrefsReenableExtension : public ExtensionControlledPrefsTest {
 392   void Initialize() override {
 393     InstallExtensionControlledPref(
 394         extension1(), kPref1, new base::StringValue("val1"));
 395     prefs()->SetExtensionDisabled(extension1()->id(),
 396                                   Extension::DISABLE_USER_ACTION);
 397     prefs()->SetExtensionEnabled(extension1()->id());
 398   }
 399   void Verify() override {
 400     std::string actual = prefs()->pref_service()->GetString(kPref1);
 401     EXPECT_EQ("val1", actual);
 402   }
 403 };
 404 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsReenableExtension) { }
 405
 406 // Mock class to test whether objects are deleted correctly.
 407 class MockStringValue : public base::StringValue {
 408  public:
 409   explicit MockStringValue(const std::string& in_value)
 410       : base::StringValue(in_value) {
 411   }
 412   virtual ~MockStringValue() {
 413     Die();
 414   }
 415   MOCK_METHOD0(Die, void());
 416 };
 417
 418 class ControlledPrefsSetExtensionControlledPref
 419     : public ExtensionControlledPrefsTest {
 420  public:
 421   void Initialize() override {
 422     MockStringValue* v1 = new MockStringValue("https://www.chromium.org");
 423     MockStringValue* v2 = new MockStringValue("https://www.chromium.org");
 424     MockStringValue* v1i = new MockStringValue("https://www.chromium.org");
 425     MockStringValue* v2i = new MockStringValue("https://www.chromium.org");
 426     // Ownership is taken, value shall not be deleted.
 427     EXPECT_CALL(*v1, Die()).Times(0);
 428     EXPECT_CALL(*v1i, Die()).Times(0);
 429     InstallExtensionControlledPref(extension1(), kPref1, v1);
 430     InstallExtensionControlledPrefIncognito(extension1(), kPref1, v1i);
 431     testing::Mock::VerifyAndClearExpectations(v1);
 432     testing::Mock::VerifyAndClearExpectations(v1i);
 433     // Make sure there is no memory leak and both values are deleted.
 434     EXPECT_CALL(*v1, Die()).Times(1);
 435     EXPECT_CALL(*v1i, Die()).Times(1);
 436     EXPECT_CALL(*v2, Die()).Times(1);
 437     EXPECT_CALL(*v2i, Die()).Times(1);
 438     InstallExtensionControlledPref(extension1(), kPref1, v2);
 439     InstallExtensionControlledPrefIncognito(extension1(), kPref1, v2i);
 440     prefs_.RecreateExtensionPrefs();
 441     testing::Mock::VerifyAndClearExpectations(v1);
 442     testing::Mock::VerifyAndClearExpectations(v1i);
 443     testing::Mock::VerifyAndClearExpectations(v2);
 444     testing::Mock::VerifyAndClearExpectations(v2i);
 445   }
 446
 447   void Verify() override {}
 448 };
 449 TEST_F(ControlledPrefsSetExtensionControlledPref,
 450        ControlledPrefsSetExtensionControlledPref) { }
 451
 452 // Tests that the switches::kDisableExtensions command-line flag prevents
 453 // extension controlled preferences from being enacted.
 454 class ControlledPrefsDisableExtensions : public ExtensionControlledPrefsTest {
 455  public:
 456   ControlledPrefsDisableExtensions()
 457       : iteration_(0) {}
 458   ~ControlledPrefsDisableExtensions() override {}
 459   void Initialize() override {
 460     InstallExtensionControlledPref(
 461         extension1(), kPref1, new base::StringValue("val1"));
 462     // This becomes only active in the second verification phase.
 463     prefs_.set_extensions_disabled(true);
 464   }
 465   void Verify() override {
 466     std::string actual = prefs()->pref_service()->GetString(kPref1);
 467     if (iteration_ == 0) {
 468       EXPECT_EQ("val1", actual);
 469       ++iteration_;
 470     } else {
 471       EXPECT_EQ(kDefaultPref1, actual);
 472     }
 473   }
 474
 475  private:
 476   int iteration_;
 477 };
 478 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { }
 479
 480 }  // namespace extensions