chrome/browser/content_settings/content_settings_pref_provider_unittest.cc

   1 // Copyright (c) 2012 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/content_settings/content_settings_pref_provider.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/command_line.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/prefs/default_pref_store.h"
  12 #include "base/prefs/overlay_user_pref_store.h"
  13 #include "base/prefs/pref_change_registrar.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/prefs/scoped_user_pref_update.h"
  16 #include "base/prefs/testing_pref_store.h"
  17 #include "base/test/simple_test_clock.h"
  18 #include "base/threading/platform_thread.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
  21 #include "chrome/browser/content_settings/content_settings_utils.h"
  22 #include "chrome/browser/prefs/browser_prefs.h"
  23 #include "chrome/browser/prefs/pref_service_mock_factory.h"
  24 #include "chrome/browser/prefs/pref_service_syncable.h"
  25 #include "chrome/common/chrome_switches.h"
  26 #include "chrome/common/pref_names.h"
  27 #include "chrome/common/url_constants.h"
  28 #include "chrome/test/base/testing_pref_service_syncable.h"
  29 #include "chrome/test/base/testing_profile.h"
  30 #include "components/pref_registry/pref_registry_syncable.h"
  31 #include "content/public/test/test_browser_thread.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33 #include "url/gurl.h"
  34
  35 using ::testing::_;
  36 using content::BrowserThread;
  37
  38 namespace content_settings {
  39
  40 class DeadlockCheckerThread : public base::PlatformThread::Delegate {
  41  public:
  42   explicit DeadlockCheckerThread(PrefProvider* provider)
  43       : provider_(provider) {}
  44
  45   virtual void ThreadMain() OVERRIDE {
  46     bool got_lock = provider_->lock_.Try();
  47     EXPECT_TRUE(got_lock);
  48     if (got_lock)
  49       provider_->lock_.Release();
  50   }
  51  private:
  52   PrefProvider* provider_;
  53   DISALLOW_COPY_AND_ASSIGN(DeadlockCheckerThread);
  54 };
  55
  56 // A helper for observing an preference changes and testing whether
  57 // |PrefProvider| holds a lock when the preferences change.
  58 class DeadlockCheckerObserver {
  59  public:
  60   // |DeadlockCheckerObserver| doesn't take the ownership of |prefs| or
  61   // ||provider|.
  62   DeadlockCheckerObserver(PrefService* prefs, PrefProvider* provider)
  63       : provider_(provider),
  64       notification_received_(false) {
  65     pref_change_registrar_.Init(prefs);
  66     pref_change_registrar_.Add(
  67         prefs::kContentSettingsPatternPairs,
  68         base::Bind(
  69             &DeadlockCheckerObserver::OnContentSettingsPatternPairsChanged,
  70             base::Unretained(this)));
  71   }
  72   virtual ~DeadlockCheckerObserver() {}
  73
  74   bool notification_received() const {
  75     return notification_received_;
  76   }
  77
  78  private:
  79   void OnContentSettingsPatternPairsChanged() {
  80     // Check whether |provider_| holds its lock. For this, we need a
  81     // separate thread.
  82     DeadlockCheckerThread thread(provider_);
  83     base::PlatformThreadHandle handle;
  84     ASSERT_TRUE(base::PlatformThread::Create(0, &thread, &handle));
  85     base::PlatformThread::Join(handle);
  86     notification_received_ = true;
  87   }
  88
  89   PrefProvider* provider_;
  90   PrefChangeRegistrar pref_change_registrar_;
  91   bool notification_received_;
  92   DISALLOW_COPY_AND_ASSIGN(DeadlockCheckerObserver);
  93 };
  94
  95 class PrefProviderTest : public testing::Test {
  96  public:
  97   PrefProviderTest() : ui_thread_(
  98       BrowserThread::UI, &message_loop_) {
  99   }
 100
 101  protected:
 102   base::MessageLoop message_loop_;
 103   content::TestBrowserThread ui_thread_;
 104 };
 105
 106 TEST_F(PrefProviderTest, Observer) {
 107   TestingProfile profile;
 108   PrefProvider pref_content_settings_provider(profile.GetPrefs(), false);
 109
 110   ContentSettingsPattern pattern =
 111       ContentSettingsPattern::FromString("[*.]example.com");
 112   content_settings::MockObserver mock_observer;
 113   EXPECT_CALL(mock_observer,
 114               OnContentSettingChanged(pattern,
 115                                       ContentSettingsPattern::Wildcard(),
 116                                       CONTENT_SETTINGS_TYPE_IMAGES,
 117                                       ""));
 118
 119   pref_content_settings_provider.AddObserver(&mock_observer);
 120
 121   pref_content_settings_provider.SetWebsiteSetting(
 122       pattern,
 123       ContentSettingsPattern::Wildcard(),
 124       CONTENT_SETTINGS_TYPE_IMAGES,
 125       std::string(),
 126       new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 127
 128   pref_content_settings_provider.ShutdownOnUIThread();
 129 }
 130
 131 // Test for regression in which the PrefProvider modified the user pref store
 132 // of the OTR unintentionally: http://crbug.com/74466.
 133 TEST_F(PrefProviderTest, Incognito) {
 134   PersistentPrefStore* user_prefs = new TestingPrefStore();
 135   OverlayUserPrefStore* otr_user_prefs =
 136       new OverlayUserPrefStore(user_prefs);
 137
 138   PrefServiceMockFactory factory;
 139   factory.set_user_prefs(make_scoped_refptr(user_prefs));
 140   scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
 141       new user_prefs::PrefRegistrySyncable);
 142   PrefServiceSyncable* regular_prefs =
 143       factory.CreateSyncable(registry.get()).release();
 144
 145   chrome::RegisterUserProfilePrefs(registry.get());
 146
 147   PrefServiceMockFactory otr_factory;
 148   otr_factory.set_user_prefs(make_scoped_refptr(otr_user_prefs));
 149   scoped_refptr<user_prefs::PrefRegistrySyncable> otr_registry(
 150       new user_prefs::PrefRegistrySyncable);
 151   PrefServiceSyncable* otr_prefs =
 152       otr_factory.CreateSyncable(otr_registry.get()).release();
 153
 154   chrome::RegisterUserProfilePrefs(otr_registry.get());
 155
 156   TestingProfile::Builder profile_builder;
 157   profile_builder.SetPrefService(make_scoped_ptr(regular_prefs));
 158   scoped_ptr<TestingProfile> profile = profile_builder.Build();
 159
 160   TestingProfile::Builder otr_profile_builder;
 161   otr_profile_builder.SetIncognito();
 162   otr_profile_builder.SetPrefService(make_scoped_ptr(otr_prefs));
 163   scoped_ptr<TestingProfile> otr_profile(otr_profile_builder.Build());
 164   profile->SetOffTheRecordProfile(otr_profile.PassAs<Profile>());
 165
 166   PrefProvider pref_content_settings_provider(regular_prefs, false);
 167   PrefProvider pref_content_settings_provider_incognito(otr_prefs, true);
 168   ContentSettingsPattern pattern =
 169       ContentSettingsPattern::FromString("[*.]example.com");
 170   pref_content_settings_provider.SetWebsiteSetting(
 171       pattern,
 172       pattern,
 173       CONTENT_SETTINGS_TYPE_IMAGES,
 174       std::string(),
 175       new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 176
 177   GURL host("http://example.com/");
 178   // The value should of course be visible in the regular PrefProvider.
 179   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 180             GetContentSetting(&pref_content_settings_provider,
 181                               host,
 182                               host,
 183                               CONTENT_SETTINGS_TYPE_IMAGES,
 184                               std::string(),
 185                               false));
 186   // And also in the OTR version.
 187   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 188             GetContentSetting(&pref_content_settings_provider_incognito,
 189                               host,
 190                               host,
 191                               CONTENT_SETTINGS_TYPE_IMAGES,
 192                               std::string(),
 193                               false));
 194   // But the value should not be overridden in the OTR user prefs accidentally.
 195   EXPECT_FALSE(otr_user_prefs->IsSetInOverlay(
 196       prefs::kContentSettingsPatternPairs));
 197
 198   pref_content_settings_provider.ShutdownOnUIThread();
 199   pref_content_settings_provider_incognito.ShutdownOnUIThread();
 200 }
 201
 202 TEST_F(PrefProviderTest, GetContentSettingsValue) {
 203   TestingProfile testing_profile;
 204   PrefProvider provider(testing_profile.GetPrefs(), false);
 205
 206   GURL primary_url("http://example.com/");
 207   ContentSettingsPattern primary_pattern =
 208       ContentSettingsPattern::FromString("[*.]example.com");
 209
 210   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 211             GetContentSetting(&provider,
 212                               primary_url,
 213                               primary_url,
 214                               CONTENT_SETTINGS_TYPE_IMAGES,
 215                               std::string(),
 216                               false));
 217
 218   EXPECT_EQ(NULL,
 219             GetContentSettingValue(&provider,
 220                                    primary_url,
 221                                    primary_url,
 222                                    CONTENT_SETTINGS_TYPE_IMAGES,
 223                                    std::string(),
 224                                    false));
 225
 226   provider.SetWebsiteSetting(primary_pattern,
 227                              primary_pattern,
 228                              CONTENT_SETTINGS_TYPE_IMAGES,
 229                              std::string(),
 230                              new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 231   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 232             GetContentSetting(&provider,
 233                               primary_url,
 234                               primary_url,
 235                               CONTENT_SETTINGS_TYPE_IMAGES,
 236                               std::string(),
 237                               false));
 238   scoped_ptr<base::Value> value_ptr(
 239       GetContentSettingValue(&provider,
 240                              primary_url,
 241                              primary_url,
 242                              CONTENT_SETTINGS_TYPE_IMAGES,
 243                              std::string(),
 244                              false));
 245   int int_value = -1;
 246   value_ptr->GetAsInteger(&int_value);
 247   EXPECT_EQ(CONTENT_SETTING_BLOCK, IntToContentSetting(int_value));
 248
 249   provider.SetWebsiteSetting(primary_pattern,
 250                              primary_pattern,
 251                              CONTENT_SETTINGS_TYPE_IMAGES,
 252                              std::string(),
 253                              NULL);
 254   EXPECT_EQ(NULL,
 255             GetContentSettingValue(&provider,
 256                                    primary_url,
 257                                    primary_url,
 258                                    CONTENT_SETTINGS_TYPE_IMAGES,
 259                                    std::string(),
 260                                    false));
 261   provider.ShutdownOnUIThread();
 262 }
 263
 264 TEST_F(PrefProviderTest, Patterns) {
 265   TestingProfile testing_profile;
 266   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
 267                                               false);
 268
 269   GURL host1("http://example.com/");
 270   GURL host2("http://www.example.com/");
 271   GURL host3("http://example.org/");
 272   GURL host4("file:///tmp/test.html");
 273   ContentSettingsPattern pattern1 =
 274       ContentSettingsPattern::FromString("[*.]example.com");
 275   ContentSettingsPattern pattern2 =
 276       ContentSettingsPattern::FromString("example.org");
 277   ContentSettingsPattern pattern3 =
 278       ContentSettingsPattern::FromString("file:///tmp/test.html");
 279
 280   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 281             GetContentSetting(&pref_content_settings_provider,
 282                               host1,
 283                               host1,
 284                               CONTENT_SETTINGS_TYPE_IMAGES,
 285                               std::string(),
 286                               false));
 287   pref_content_settings_provider.SetWebsiteSetting(
 288       pattern1,
 289       pattern1,
 290       CONTENT_SETTINGS_TYPE_IMAGES,
 291       std::string(),
 292       new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 293   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 294             GetContentSetting(&pref_content_settings_provider,
 295                               host1,
 296                               host1,
 297                               CONTENT_SETTINGS_TYPE_IMAGES,
 298                               std::string(),
 299                               false));
 300   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 301             GetContentSetting(&pref_content_settings_provider,
 302                               host2,
 303                               host2,
 304                               CONTENT_SETTINGS_TYPE_IMAGES,
 305                               std::string(),
 306                               false));
 307
 308   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 309             GetContentSetting(&pref_content_settings_provider,
 310                               host3,
 311                               host3,
 312                               CONTENT_SETTINGS_TYPE_IMAGES,
 313                               std::string(),
 314                               false));
 315   pref_content_settings_provider.SetWebsiteSetting(
 316       pattern2,
 317       pattern2,
 318       CONTENT_SETTINGS_TYPE_IMAGES,
 319       std::string(),
 320       new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 321   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 322             GetContentSetting(&pref_content_settings_provider,
 323                               host3,
 324                               host3,
 325                               CONTENT_SETTINGS_TYPE_IMAGES,
 326                               std::string(),
 327                               false));
 328
 329   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 330             GetContentSetting(&pref_content_settings_provider,
 331                               host4,
 332                               host4,
 333                               CONTENT_SETTINGS_TYPE_IMAGES,
 334                               std::string(),
 335                               false));
 336   pref_content_settings_provider.SetWebsiteSetting(
 337       pattern3,
 338       pattern3,
 339       CONTENT_SETTINGS_TYPE_IMAGES,
 340       std::string(),
 341       new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 342   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 343             GetContentSetting(&pref_content_settings_provider,
 344                               host4,
 345                               host4,
 346                               CONTENT_SETTINGS_TYPE_IMAGES,
 347                               std::string(),
 348                               false));
 349
 350   pref_content_settings_provider.ShutdownOnUIThread();
 351 }
 352
 353 TEST_F(PrefProviderTest, ResourceIdentifier) {
 354   TestingProfile testing_profile;
 355   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
 356                                               false);
 357
 358   GURL host("http://example.com/");
 359   ContentSettingsPattern pattern =
 360       ContentSettingsPattern::FromString("[*.]example.com");
 361   std::string resource1("someplugin");
 362   std::string resource2("otherplugin");
 363
 364   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 365             GetContentSetting(
 366                 &pref_content_settings_provider,
 367                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS,
 368                 resource1, false));
 369   pref_content_settings_provider.SetWebsiteSetting(
 370       pattern,
 371       pattern,
 372       CONTENT_SETTINGS_TYPE_PLUGINS,
 373       resource1,
 374       new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 375   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 376             GetContentSetting(
 377                 &pref_content_settings_provider,
 378                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS,
 379                 resource1, false));
 380   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 381             GetContentSetting(
 382                 &pref_content_settings_provider,
 383                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS,
 384                 resource2, false));
 385
 386   pref_content_settings_provider.ShutdownOnUIThread();
 387 }
 388
 389 TEST_F(PrefProviderTest, AutoSubmitCertificateContentSetting) {
 390   TestingProfile profile;
 391   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 392   GURL primary_url("https://www.example.com");
 393   GURL secondary_url("https://www.sample.com");
 394
 395   PrefProvider provider(prefs, false);
 396
 397   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 398             GetContentSetting(
 399                 &provider,
 400                 primary_url,
 401                 primary_url,
 402                 CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 403                 std::string(),
 404                 false));
 405
 406   provider.SetWebsiteSetting(ContentSettingsPattern::FromURL(primary_url),
 407                              ContentSettingsPattern::Wildcard(),
 408                              CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 409                              std::string(),
 410                              new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 411   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 412             GetContentSetting(
 413                 &provider,
 414                 primary_url,
 415                 secondary_url,
 416                 CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 417                 std::string(),
 418                 false));
 419   provider.ShutdownOnUIThread();
 420 }
 421
 422 // http://crosbug.com/17760
 423 TEST_F(PrefProviderTest, Deadlock) {
 424   TestingPrefServiceSyncable prefs;
 425   PrefProvider::RegisterProfilePrefs(prefs.registry());
 426
 427   // Chain of events: a preference changes, |PrefProvider| notices it, and reads
 428   // and writes the preference. When the preference is written, a notification
 429   // is sent, and this used to happen when |PrefProvider| was still holding its
 430   // lock.
 431
 432   PrefProvider provider(&prefs, false);
 433   DeadlockCheckerObserver observer(&prefs, &provider);
 434   {
 435     DictionaryPrefUpdate update(&prefs,
 436                                 prefs::kContentSettingsPatternPairs);
 437     base::DictionaryValue* mutable_settings = update.Get();
 438     mutable_settings->SetWithoutPathExpansion("www.example.com,*",
 439                                               new base::DictionaryValue());
 440   }
 441   EXPECT_TRUE(observer.notification_received());
 442
 443   provider.ShutdownOnUIThread();
 444 }
 445
 446 TEST_F(PrefProviderTest, LastUsage) {
 447   TestingProfile testing_profile;
 448   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
 449                                               false);
 450   base::SimpleTestClock* test_clock = new base::SimpleTestClock;
 451   test_clock->SetNow(base::Time::Now());
 452
 453   pref_content_settings_provider.SetClockForTesting(
 454       scoped_ptr<base::Clock>(test_clock));
 455   GURL host("http://example.com/");
 456   ContentSettingsPattern pattern =
 457       ContentSettingsPattern::FromString("[*.]example.com");
 458
 459   base::Time no_usage = pref_content_settings_provider.GetLastUsage(
 460       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 461   EXPECT_EQ(no_usage.ToDoubleT(), 0);
 462
 463   pref_content_settings_provider.UpdateLastUsage(
 464       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 465   base::Time first = pref_content_settings_provider.GetLastUsage(
 466       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 467
 468   test_clock->Advance(base::TimeDelta::FromSeconds(10));
 469
 470   pref_content_settings_provider.UpdateLastUsage(
 471       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 472   base::Time second = pref_content_settings_provider.GetLastUsage(
 473       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 474
 475   base::TimeDelta delta = second - first;
 476   EXPECT_EQ(delta.InSeconds(), 10);
 477
 478   pref_content_settings_provider.ShutdownOnUIThread();
 479 }
 480
 481 }  // namespace content_settings