chrome/browser/content_settings/host_content_settings_map_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 "base/auto_reset.h"
   6 #include "base/command_line.h"
   7 #include "base/json/json_reader.h"
   8 #include "base/json/json_writer.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/scoped_user_pref_update.h"
  12 #include "chrome/browser/content_settings/content_settings_details.h"
  13 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
  14 #include "chrome/browser/content_settings/cookie_settings.h"
  15 #include "chrome/browser/content_settings/host_content_settings_map.h"
  16 #include "chrome/browser/content_settings/mock_settings_observer.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "chrome/common/url_constants.h"
  20 #include "chrome/test/base/testing_pref_service_syncable.h"
  21 #include "chrome/test/base/testing_profile.h"
  22 #include "content/public/test/test_browser_thread.h"
  23 #include "net/base/static_cookie_policy.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "url/gurl.h"
  26
  27 using content::BrowserThread;
  28
  29 using ::testing::_;
  30
  31 class HostContentSettingsMapTest : public testing::Test {
  32  public:
  33   HostContentSettingsMapTest() : ui_thread_(BrowserThread::UI, &message_loop_) {
  34   }
  35
  36  protected:
  37   base::MessageLoop message_loop_;
  38   content::TestBrowserThread ui_thread_;
  39 };
  40
  41 TEST_F(HostContentSettingsMapTest, DefaultValues) {
  42   TestingProfile profile;
  43   HostContentSettingsMap* host_content_settings_map =
  44       profile.GetHostContentSettingsMap();
  45
  46   // Check setting defaults.
  47   EXPECT_EQ(CONTENT_SETTING_ALLOW,
  48             host_content_settings_map->GetDefaultContentSetting(
  49                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
  50   host_content_settings_map->SetDefaultContentSetting(
  51       CONTENT_SETTINGS_TYPE_IMAGES, CONTENT_SETTING_BLOCK);
  52   EXPECT_EQ(CONTENT_SETTING_BLOCK,
  53             host_content_settings_map->GetDefaultContentSetting(
  54                 CONTENT_SETTINGS_TYPE_IMAGES, NULL));
  55   EXPECT_EQ(CONTENT_SETTING_ALLOW, host_content_settings_map->GetContentSetting(
  56                 GURL(chrome::kChromeUINewTabURL),
  57                 GURL(chrome::kChromeUINewTabURL),
  58                 CONTENT_SETTINGS_TYPE_IMAGES,
  59                 std::string()));
  60   {
  61     host_content_settings_map->SetDefaultContentSetting(
  62         CONTENT_SETTINGS_TYPE_PLUGINS, CONTENT_SETTING_ASK);
  63     EXPECT_EQ(CONTENT_SETTING_ASK,
  64               host_content_settings_map->GetDefaultContentSetting(
  65                   CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
  66   }
  67   host_content_settings_map->SetDefaultContentSetting(
  68       CONTENT_SETTINGS_TYPE_POPUPS, CONTENT_SETTING_ALLOW);
  69   EXPECT_EQ(CONTENT_SETTING_ALLOW,
  70             host_content_settings_map->GetDefaultContentSetting(
  71                 CONTENT_SETTINGS_TYPE_POPUPS, NULL));
  72 }
  73
  74 TEST_F(HostContentSettingsMapTest, IndividualSettings) {
  75   TestingProfile profile;
  76   HostContentSettingsMap* host_content_settings_map =
  77       profile.GetHostContentSettingsMap();
  78
  79   // Check returning individual settings.
  80   GURL host("http://example.com/");
  81   ContentSettingsPattern pattern =
  82        ContentSettingsPattern::FromString("[*.]example.com");
  83   EXPECT_EQ(CONTENT_SETTING_ALLOW,
  84             host_content_settings_map->GetContentSetting(
  85                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
  86   host_content_settings_map->SetContentSetting(
  87       pattern,
  88       ContentSettingsPattern::Wildcard(),
  89       CONTENT_SETTINGS_TYPE_IMAGES,
  90       std::string(),
  91       CONTENT_SETTING_DEFAULT);
  92   EXPECT_EQ(CONTENT_SETTING_ALLOW,
  93             host_content_settings_map->GetContentSetting(
  94                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
  95   host_content_settings_map->SetContentSetting(
  96       pattern,
  97       ContentSettingsPattern::Wildcard(),
  98       CONTENT_SETTINGS_TYPE_IMAGES,
  99       std::string(),
 100       CONTENT_SETTING_BLOCK);
 101   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 102             host_content_settings_map->GetContentSetting(
 103                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 104   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 105             host_content_settings_map->GetContentSetting(
 106                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS, std::string()));
 107
 108   // Check returning all settings for a host.
 109   host_content_settings_map->SetContentSetting(
 110       pattern,
 111       ContentSettingsPattern::Wildcard(),
 112       CONTENT_SETTINGS_TYPE_IMAGES,
 113       std::string(),
 114       CONTENT_SETTING_DEFAULT);
 115   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 116             host_content_settings_map->GetContentSetting(
 117                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 118   host_content_settings_map->SetContentSetting(
 119       pattern,
 120       ContentSettingsPattern::Wildcard(),
 121       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 122       std::string(),
 123       CONTENT_SETTING_BLOCK);
 124   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 125             host_content_settings_map->GetContentSetting(
 126                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 127   host_content_settings_map->SetContentSetting(
 128       pattern,
 129       ContentSettingsPattern::Wildcard(),
 130       CONTENT_SETTINGS_TYPE_PLUGINS,
 131       std::string(),
 132       CONTENT_SETTING_ALLOW);
 133   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 134             host_content_settings_map->GetContentSetting(
 135                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS, std::string()));
 136   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 137             host_content_settings_map->GetContentSetting(
 138                 host, host, CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
 139   EXPECT_EQ(CONTENT_SETTING_ASK,
 140             host_content_settings_map->GetContentSetting(
 141                 host, host, CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 142   EXPECT_EQ(
 143       CONTENT_SETTING_ASK,
 144       host_content_settings_map->GetContentSetting(
 145           host, host, CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string()));
 146   EXPECT_EQ(CONTENT_SETTING_ASK,
 147             host_content_settings_map->GetContentSetting(
 148                 host, host, CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string()));
 149   EXPECT_EQ(CONTENT_SETTING_ASK,
 150             host_content_settings_map->GetContentSetting(
 151                 host, host, CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string()));
 152
 153   // Check returning all hosts for a setting.
 154   ContentSettingsPattern pattern2 =
 155        ContentSettingsPattern::FromString("[*.]example.org");
 156   host_content_settings_map->SetContentSetting(
 157       pattern2,
 158       ContentSettingsPattern::Wildcard(),
 159       CONTENT_SETTINGS_TYPE_IMAGES,
 160       std::string(),
 161       CONTENT_SETTING_BLOCK);
 162   host_content_settings_map->SetContentSetting(
 163       pattern2,
 164       ContentSettingsPattern::Wildcard(),
 165       CONTENT_SETTINGS_TYPE_PLUGINS,
 166       std::string(),
 167       CONTENT_SETTING_BLOCK);
 168   ContentSettingsForOneType host_settings;
 169   host_content_settings_map->GetSettingsForOneType(
 170       CONTENT_SETTINGS_TYPE_IMAGES, std::string(), &host_settings);
 171   // |host_settings| contains the default setting and an exception.
 172   EXPECT_EQ(2U, host_settings.size());
 173   host_content_settings_map->GetSettingsForOneType(
 174       CONTENT_SETTINGS_TYPE_PLUGINS, std::string(), &host_settings);
 175   // |host_settings| contains the default setting and 2 exceptions.
 176   EXPECT_EQ(3U, host_settings.size());
 177   host_content_settings_map->GetSettingsForOneType(
 178       CONTENT_SETTINGS_TYPE_POPUPS, std::string(), &host_settings);
 179   // |host_settings| contains only the default setting.
 180   EXPECT_EQ(1U, host_settings.size());
 181 }
 182
 183 TEST_F(HostContentSettingsMapTest, Clear) {
 184   TestingProfile profile;
 185   HostContentSettingsMap* host_content_settings_map =
 186       profile.GetHostContentSettingsMap();
 187
 188   // Check clearing one type.
 189   ContentSettingsPattern pattern =
 190        ContentSettingsPattern::FromString("[*.]example.org");
 191   ContentSettingsPattern pattern2 =
 192       ContentSettingsPattern::FromString("[*.]example.net");
 193   host_content_settings_map->SetContentSetting(
 194       pattern2,
 195       ContentSettingsPattern::Wildcard(),
 196       CONTENT_SETTINGS_TYPE_IMAGES,
 197       std::string(),
 198       CONTENT_SETTING_BLOCK);
 199   host_content_settings_map->SetContentSetting(
 200       pattern,
 201       ContentSettingsPattern::Wildcard(),
 202       CONTENT_SETTINGS_TYPE_IMAGES,
 203       std::string(),
 204       CONTENT_SETTING_BLOCK);
 205   host_content_settings_map->SetContentSetting(
 206       pattern,
 207       ContentSettingsPattern::Wildcard(),
 208       CONTENT_SETTINGS_TYPE_PLUGINS,
 209       std::string(),
 210       CONTENT_SETTING_BLOCK);
 211   host_content_settings_map->SetContentSetting(
 212       pattern2,
 213       ContentSettingsPattern::Wildcard(),
 214       CONTENT_SETTINGS_TYPE_IMAGES,
 215       std::string(),
 216       CONTENT_SETTING_BLOCK);
 217   host_content_settings_map->ClearSettingsForOneType(
 218       CONTENT_SETTINGS_TYPE_IMAGES);
 219   ContentSettingsForOneType host_settings;
 220   host_content_settings_map->GetSettingsForOneType(
 221       CONTENT_SETTINGS_TYPE_IMAGES, std::string(), &host_settings);
 222   // |host_settings| contains only the default setting.
 223   EXPECT_EQ(1U, host_settings.size());
 224   host_content_settings_map->GetSettingsForOneType(
 225       CONTENT_SETTINGS_TYPE_PLUGINS, std::string(), &host_settings);
 226   // |host_settings| contains the default setting and an exception.
 227   EXPECT_EQ(2U, host_settings.size());
 228 }
 229
 230 TEST_F(HostContentSettingsMapTest, Patterns) {
 231   TestingProfile profile;
 232   HostContentSettingsMap* host_content_settings_map =
 233       profile.GetHostContentSettingsMap();
 234
 235   GURL host1("http://example.com/");
 236   GURL host2("http://www.example.com/");
 237   GURL host3("http://example.org/");
 238   ContentSettingsPattern pattern1 =
 239        ContentSettingsPattern::FromString("[*.]example.com");
 240   ContentSettingsPattern pattern2 =
 241        ContentSettingsPattern::FromString("example.org");
 242   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 243             host_content_settings_map->GetContentSetting(
 244                 host1, host1, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 245   host_content_settings_map->SetContentSetting(
 246       pattern1,
 247       ContentSettingsPattern::Wildcard(),
 248       CONTENT_SETTINGS_TYPE_IMAGES,
 249       std::string(),
 250       CONTENT_SETTING_BLOCK);
 251   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 252             host_content_settings_map->GetContentSetting(
 253                 host1, host1, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 254   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 255             host_content_settings_map->GetContentSetting(
 256                 host2, host2, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 257   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 258             host_content_settings_map->GetContentSetting(
 259                 host3, host3, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 260   host_content_settings_map->SetContentSetting(
 261       pattern2,
 262       ContentSettingsPattern::Wildcard(),
 263       CONTENT_SETTINGS_TYPE_IMAGES,
 264       std::string(),
 265       CONTENT_SETTING_BLOCK);
 266   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 267             host_content_settings_map->GetContentSetting(
 268                 host3, host3, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 269 }
 270
 271 TEST_F(HostContentSettingsMapTest, Observer) {
 272   TestingProfile profile;
 273   HostContentSettingsMap* host_content_settings_map =
 274       profile.GetHostContentSettingsMap();
 275   MockSettingsObserver observer(host_content_settings_map);
 276
 277   ContentSettingsPattern primary_pattern =
 278       ContentSettingsPattern::FromString("[*.]example.com");
 279   ContentSettingsPattern secondary_pattern =
 280       ContentSettingsPattern::Wildcard();
 281   EXPECT_CALL(observer,
 282               OnContentSettingsChanged(host_content_settings_map,
 283                                        CONTENT_SETTINGS_TYPE_IMAGES,
 284                                        false,
 285                                        primary_pattern,
 286                                        secondary_pattern,
 287                                        false));
 288   host_content_settings_map->SetContentSetting(
 289       primary_pattern,
 290       secondary_pattern,
 291       CONTENT_SETTINGS_TYPE_IMAGES,
 292       std::string(),
 293       CONTENT_SETTING_ALLOW);
 294   ::testing::Mock::VerifyAndClearExpectations(&observer);
 295
 296   EXPECT_CALL(observer,
 297               OnContentSettingsChanged(host_content_settings_map,
 298                                        CONTENT_SETTINGS_TYPE_IMAGES, false,
 299                                        _, _, true));
 300   host_content_settings_map->ClearSettingsForOneType(
 301       CONTENT_SETTINGS_TYPE_IMAGES);
 302   ::testing::Mock::VerifyAndClearExpectations(&observer);
 303
 304   EXPECT_CALL(observer,
 305               OnContentSettingsChanged(host_content_settings_map,
 306                                        CONTENT_SETTINGS_TYPE_IMAGES, false,
 307                                        _, _, true));
 308   host_content_settings_map->SetDefaultContentSetting(
 309       CONTENT_SETTINGS_TYPE_IMAGES, CONTENT_SETTING_BLOCK);
 310 }
 311
 312 TEST_F(HostContentSettingsMapTest, ObserveDefaultPref) {
 313   TestingProfile profile;
 314   HostContentSettingsMap* host_content_settings_map =
 315       profile.GetHostContentSettingsMap();
 316
 317   PrefService* prefs = profile.GetPrefs();
 318
 319   // Make a copy of the default pref value so we can reset it later.
 320   scoped_ptr<base::Value> default_value(prefs->FindPreference(
 321       prefs::kDefaultContentSettings)->GetValue()->DeepCopy());
 322
 323   GURL host("http://example.com");
 324
 325   host_content_settings_map->SetDefaultContentSetting(
 326       CONTENT_SETTINGS_TYPE_IMAGES, CONTENT_SETTING_BLOCK);
 327   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 328             host_content_settings_map->GetContentSetting(
 329                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 330
 331   // Make a copy of the pref's new value so we can reset it later.
 332   scoped_ptr<base::Value> new_value(prefs->FindPreference(
 333       prefs::kDefaultContentSettings)->GetValue()->DeepCopy());
 334
 335   // Clearing the backing pref should also clear the internal cache.
 336   prefs->Set(prefs::kDefaultContentSettings, *default_value);
 337   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 338             host_content_settings_map->GetContentSetting(
 339                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 340
 341   // Reseting the pref to its previous value should update the cache.
 342   prefs->Set(prefs::kDefaultContentSettings, *new_value);
 343   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 344             host_content_settings_map->GetContentSetting(
 345                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 346 }
 347
 348 TEST_F(HostContentSettingsMapTest, ObserveExceptionPref) {
 349   TestingProfile profile;
 350   HostContentSettingsMap* host_content_settings_map =
 351       profile.GetHostContentSettingsMap();
 352
 353   PrefService* prefs = profile.GetPrefs();
 354
 355   // Make a copy of the default pref value so we can reset it later.
 356   scoped_ptr<base::Value> default_value(prefs->FindPreference(
 357       prefs::kContentSettingsPatternPairs)->GetValue()->DeepCopy());
 358
 359   ContentSettingsPattern pattern =
 360        ContentSettingsPattern::FromString("[*.]example.com");
 361   GURL host("http://example.com");
 362
 363   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 364             host_content_settings_map->GetContentSetting(
 365                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 366
 367   host_content_settings_map->SetContentSetting(
 368       pattern,
 369       ContentSettingsPattern::Wildcard(),
 370       CONTENT_SETTINGS_TYPE_IMAGES,
 371       std::string(),
 372       CONTENT_SETTING_BLOCK);
 373   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 374             host_content_settings_map->GetContentSetting(
 375                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 376
 377   // Make a copy of the pref's new value so we can reset it later.
 378   scoped_ptr<base::Value> new_value(prefs->FindPreference(
 379       prefs::kContentSettingsPatternPairs)->GetValue()->DeepCopy());
 380
 381   // Clearing the backing pref should also clear the internal cache.
 382   prefs->Set(prefs::kContentSettingsPatternPairs, *default_value);
 383   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 384             host_content_settings_map->GetContentSetting(
 385                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 386
 387   // Reseting the pref to its previous value should update the cache.
 388   prefs->Set(prefs::kContentSettingsPatternPairs, *new_value);
 389   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 390             host_content_settings_map->GetContentSetting(
 391                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 392 }
 393
 394 TEST_F(HostContentSettingsMapTest, HostTrimEndingDotCheck) {
 395   TestingProfile profile;
 396   HostContentSettingsMap* host_content_settings_map =
 397       profile.GetHostContentSettingsMap();
 398   CookieSettings* cookie_settings =
 399       CookieSettings::Factory::GetForProfile(&profile).get();
 400
 401   ContentSettingsPattern pattern =
 402        ContentSettingsPattern::FromString("[*.]example.com");
 403   GURL host_ending_with_dot("http://example.com./");
 404
 405   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 406             host_content_settings_map->GetContentSetting(
 407                 host_ending_with_dot,
 408                 host_ending_with_dot,
 409                 CONTENT_SETTINGS_TYPE_IMAGES,
 410                 std::string()));
 411   host_content_settings_map->SetContentSetting(
 412       pattern,
 413       ContentSettingsPattern::Wildcard(),
 414       CONTENT_SETTINGS_TYPE_IMAGES,
 415       std::string(),
 416       CONTENT_SETTING_DEFAULT);
 417   EXPECT_EQ(
 418       CONTENT_SETTING_ALLOW,
 419       host_content_settings_map->GetContentSetting(host_ending_with_dot,
 420                                                    host_ending_with_dot,
 421                                                    CONTENT_SETTINGS_TYPE_IMAGES,
 422                                                    std::string()));
 423   host_content_settings_map->SetContentSetting(
 424       pattern,
 425       ContentSettingsPattern::Wildcard(),
 426       CONTENT_SETTINGS_TYPE_IMAGES,
 427       std::string(),
 428       CONTENT_SETTING_BLOCK);
 429   EXPECT_EQ(
 430       CONTENT_SETTING_BLOCK,
 431       host_content_settings_map->GetContentSetting(host_ending_with_dot,
 432                                                    host_ending_with_dot,
 433                                                    CONTENT_SETTINGS_TYPE_IMAGES,
 434                                                    std::string()));
 435
 436   EXPECT_TRUE(cookie_settings->IsSettingCookieAllowed(
 437       host_ending_with_dot, host_ending_with_dot));
 438   host_content_settings_map->SetContentSetting(
 439       pattern,
 440       ContentSettingsPattern::Wildcard(),
 441       CONTENT_SETTINGS_TYPE_COOKIES,
 442       std::string(),
 443       CONTENT_SETTING_DEFAULT);
 444   EXPECT_TRUE(cookie_settings->IsSettingCookieAllowed(
 445       host_ending_with_dot, host_ending_with_dot));
 446   host_content_settings_map->SetContentSetting(
 447       pattern,
 448       ContentSettingsPattern::Wildcard(),
 449       CONTENT_SETTINGS_TYPE_COOKIES,
 450       std::string(),
 451       CONTENT_SETTING_BLOCK);
 452   EXPECT_FALSE(cookie_settings->IsSettingCookieAllowed(
 453       host_ending_with_dot, host_ending_with_dot));
 454
 455   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 456             host_content_settings_map->GetContentSetting(
 457                 host_ending_with_dot,
 458                 host_ending_with_dot,
 459                 CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 460                 std::string()));
 461   host_content_settings_map->SetContentSetting(
 462       pattern,
 463       ContentSettingsPattern::Wildcard(),
 464       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 465       std::string(),
 466       CONTENT_SETTING_DEFAULT);
 467   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 468             host_content_settings_map->GetContentSetting(
 469                 host_ending_with_dot,
 470                 host_ending_with_dot,
 471                 CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 472                 std::string()));
 473   host_content_settings_map->SetContentSetting(
 474       pattern,
 475       ContentSettingsPattern::Wildcard(),
 476       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 477       std::string(),
 478       CONTENT_SETTING_BLOCK);
 479   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 480             host_content_settings_map->GetContentSetting(
 481                 host_ending_with_dot,
 482                 host_ending_with_dot,
 483                 CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 484                 std::string()));
 485
 486   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 487             host_content_settings_map->GetContentSetting(
 488                 host_ending_with_dot,
 489                 host_ending_with_dot,
 490                 CONTENT_SETTINGS_TYPE_PLUGINS,
 491                 std::string()));
 492   host_content_settings_map->SetContentSetting(
 493       pattern,
 494       ContentSettingsPattern::Wildcard(),
 495       CONTENT_SETTINGS_TYPE_PLUGINS,
 496       std::string(),
 497       CONTENT_SETTING_DEFAULT);
 498   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 499             host_content_settings_map->GetContentSetting(
 500                 host_ending_with_dot,
 501                 host_ending_with_dot,
 502                 CONTENT_SETTINGS_TYPE_PLUGINS,
 503                 std::string()));
 504   host_content_settings_map->SetContentSetting(
 505       pattern,
 506       ContentSettingsPattern::Wildcard(),
 507       CONTENT_SETTINGS_TYPE_PLUGINS,
 508       std::string(),
 509       CONTENT_SETTING_BLOCK);
 510   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 511             host_content_settings_map->GetContentSetting(
 512                 host_ending_with_dot,
 513                 host_ending_with_dot,
 514                 CONTENT_SETTINGS_TYPE_PLUGINS,
 515                 std::string()));
 516
 517   EXPECT_EQ(
 518       CONTENT_SETTING_BLOCK,
 519       host_content_settings_map->GetContentSetting(host_ending_with_dot,
 520                                                    host_ending_with_dot,
 521                                                    CONTENT_SETTINGS_TYPE_POPUPS,
 522                                                    std::string()));
 523   host_content_settings_map->SetContentSetting(
 524       pattern,
 525       ContentSettingsPattern::Wildcard(),
 526       CONTENT_SETTINGS_TYPE_POPUPS,
 527       std::string(),
 528       CONTENT_SETTING_DEFAULT);
 529   EXPECT_EQ(
 530       CONTENT_SETTING_BLOCK,
 531       host_content_settings_map->GetContentSetting(host_ending_with_dot,
 532                                                    host_ending_with_dot,
 533                                                    CONTENT_SETTINGS_TYPE_POPUPS,
 534                                                    std::string()));
 535   host_content_settings_map->SetContentSetting(
 536       pattern,
 537       ContentSettingsPattern::Wildcard(),
 538       CONTENT_SETTINGS_TYPE_POPUPS,
 539       std::string(),
 540       CONTENT_SETTING_ALLOW);
 541   EXPECT_EQ(
 542       CONTENT_SETTING_ALLOW,
 543       host_content_settings_map->GetContentSetting(host_ending_with_dot,
 544                                                    host_ending_with_dot,
 545                                                    CONTENT_SETTINGS_TYPE_POPUPS,
 546                                                    std::string()));
 547 }
 548
 549 TEST_F(HostContentSettingsMapTest, NestedSettings) {
 550   TestingProfile profile;
 551   HostContentSettingsMap* host_content_settings_map =
 552       profile.GetHostContentSettingsMap();
 553
 554   GURL host("http://a.b.example.com/");
 555   ContentSettingsPattern pattern1 =
 556        ContentSettingsPattern::FromString("[*.]example.com");
 557   ContentSettingsPattern pattern2 =
 558        ContentSettingsPattern::FromString("[*.]b.example.com");
 559   ContentSettingsPattern pattern3 =
 560        ContentSettingsPattern::FromString("a.b.example.com");
 561
 562   host_content_settings_map->SetContentSetting(
 563       pattern1,
 564       ContentSettingsPattern::Wildcard(),
 565       CONTENT_SETTINGS_TYPE_IMAGES,
 566       std::string(),
 567       CONTENT_SETTING_BLOCK);
 568
 569   host_content_settings_map->SetContentSetting(
 570       pattern2,
 571       ContentSettingsPattern::Wildcard(),
 572       CONTENT_SETTINGS_TYPE_COOKIES,
 573       std::string(),
 574       CONTENT_SETTING_BLOCK);
 575
 576   host_content_settings_map->SetContentSetting(
 577       pattern3,
 578       ContentSettingsPattern::Wildcard(),
 579       CONTENT_SETTINGS_TYPE_PLUGINS,
 580       std::string(),
 581       CONTENT_SETTING_BLOCK);
 582   host_content_settings_map->SetDefaultContentSetting(
 583       CONTENT_SETTINGS_TYPE_JAVASCRIPT, CONTENT_SETTING_BLOCK);
 584
 585   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 586             host_content_settings_map->GetContentSetting(
 587                 host, host, CONTENT_SETTINGS_TYPE_COOKIES, std::string()));
 588   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 589             host_content_settings_map->GetContentSetting(
 590                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 591   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 592             host_content_settings_map->GetContentSetting(
 593                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 594   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 595             host_content_settings_map->GetContentSetting(
 596                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS, std::string()));
 597   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 598             host_content_settings_map->GetContentSetting(
 599                 host, host, CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
 600   EXPECT_EQ(CONTENT_SETTING_ASK,
 601             host_content_settings_map->GetContentSetting(
 602                 host, host, CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string()));
 603   EXPECT_EQ(
 604       CONTENT_SETTING_ASK,
 605       host_content_settings_map->GetContentSetting(
 606           host, host, CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string()));
 607   EXPECT_EQ(CONTENT_SETTING_ASK,
 608             host_content_settings_map->GetContentSetting(
 609                 host, host, CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string()));
 610   EXPECT_EQ(CONTENT_SETTING_ASK,
 611             host_content_settings_map->GetContentSetting(
 612                 host, host, CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string()));
 613 }
 614
 615 TEST_F(HostContentSettingsMapTest, OffTheRecord) {
 616   TestingProfile profile;
 617   HostContentSettingsMap* host_content_settings_map =
 618       profile.GetHostContentSettingsMap();
 619   scoped_refptr<HostContentSettingsMap> otr_map(
 620       new HostContentSettingsMap(profile.GetPrefs(),
 621                                  true));
 622
 623   GURL host("http://example.com/");
 624   ContentSettingsPattern pattern =
 625        ContentSettingsPattern::FromString("[*.]example.com");
 626
 627   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 628             host_content_settings_map->GetContentSetting(
 629                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 630   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 631             otr_map->GetContentSetting(
 632                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 633
 634   // Changing content settings on the main map should also affect the
 635   // incognito map.
 636   host_content_settings_map->SetContentSetting(
 637       pattern,
 638       ContentSettingsPattern::Wildcard(),
 639       CONTENT_SETTINGS_TYPE_IMAGES,
 640       std::string(),
 641       CONTENT_SETTING_BLOCK);
 642   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 643             host_content_settings_map->GetContentSetting(
 644                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 645   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 646             otr_map->GetContentSetting(
 647                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 648
 649   // Changing content settings on the incognito map should NOT affect the
 650   // main map.
 651   otr_map->SetContentSetting(pattern,
 652                              ContentSettingsPattern::Wildcard(),
 653                              CONTENT_SETTINGS_TYPE_IMAGES,
 654                              std::string(),
 655                              CONTENT_SETTING_ALLOW);
 656   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 657             host_content_settings_map->GetContentSetting(
 658                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 659   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 660             otr_map->GetContentSetting(
 661                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 662
 663   otr_map->ShutdownOnUIThread();
 664 }
 665
 666 // For a single Unicode encoded pattern, check if it gets converted to punycode
 667 // and old pattern gets deleted.
 668 TEST_F(HostContentSettingsMapTest, CanonicalizeExceptionsUnicodeOnly) {
 669   TestingProfile profile;
 670   PrefService* prefs = profile.GetPrefs();
 671
 672   // Set utf-8 data.
 673   {
 674     DictionaryPrefUpdate update(prefs, prefs::kContentSettingsPatternPairs);
 675     base::DictionaryValue* all_settings_dictionary = update.Get();
 676     ASSERT_TRUE(NULL != all_settings_dictionary);
 677
 678     base::DictionaryValue* dummy_payload = new base::DictionaryValue;
 679     dummy_payload->SetInteger("images", CONTENT_SETTING_ALLOW);
 680     all_settings_dictionary->SetWithoutPathExpansion("[*.]\xC4\x87ira.com,*",
 681                                                      dummy_payload);
 682   }
 683   profile.GetHostContentSettingsMap();
 684
 685   const base::DictionaryValue* all_settings_dictionary =
 686       prefs->GetDictionary(prefs::kContentSettingsPatternPairs);
 687   const base::DictionaryValue* result = NULL;
 688   EXPECT_FALSE(all_settings_dictionary->GetDictionaryWithoutPathExpansion(
 689       "[*.]\xC4\x87ira.com,*", &result));
 690   EXPECT_TRUE(all_settings_dictionary->GetDictionaryWithoutPathExpansion(
 691       "[*.]xn--ira-ppa.com,*", &result));
 692 }
 693
 694 // If both Unicode and its punycode pattern exist, make sure we don't touch the
 695 // settings for the punycode, and that Unicode pattern gets deleted.
 696 TEST_F(HostContentSettingsMapTest, CanonicalizeExceptionsUnicodeAndPunycode) {
 697   TestingProfile profile;
 698
 699   scoped_ptr<base::Value> value(base::JSONReader::Read(
 700       "{\"[*.]\\xC4\\x87ira.com,*\":{\"images\":1}}"));
 701   profile.GetPrefs()->Set(prefs::kContentSettingsPatternPairs, *value);
 702
 703   // Set punycode equivalent, with different setting.
 704   scoped_ptr<base::Value> puny_value(base::JSONReader::Read(
 705       "{\"[*.]xn--ira-ppa.com,*\":{\"images\":2}}"));
 706   profile.GetPrefs()->Set(prefs::kContentSettingsPatternPairs, *puny_value);
 707
 708   // Initialize the content map.
 709   profile.GetHostContentSettingsMap();
 710
 711   const base::DictionaryValue* content_setting_prefs =
 712       profile.GetPrefs()->GetDictionary(prefs::kContentSettingsPatternPairs);
 713   std::string prefs_as_json;
 714   base::JSONWriter::Write(content_setting_prefs, &prefs_as_json);
 715   EXPECT_STREQ("{\"[*.]xn--ira-ppa.com,*\":{\"images\":2}}",
 716                prefs_as_json.c_str());
 717 }
 718
 719 // If a default-content-setting is managed, the managed value should be used
 720 // instead of the default value.
 721 TEST_F(HostContentSettingsMapTest, ManagedDefaultContentSetting) {
 722   TestingProfile profile;
 723   HostContentSettingsMap* host_content_settings_map =
 724       profile.GetHostContentSettingsMap();
 725   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 726
 727   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 728             host_content_settings_map->GetDefaultContentSetting(
 729                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
 730
 731   // Set managed-default-content-setting through the coresponding preferences.
 732   prefs->SetManagedPref(prefs::kManagedDefaultJavaScriptSetting,
 733                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 734   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 735             host_content_settings_map->GetDefaultContentSetting(
 736                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
 737
 738   // Remove managed-default-content-settings-preferences.
 739   prefs->RemoveManagedPref(prefs::kManagedDefaultJavaScriptSetting);
 740   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 741             host_content_settings_map->GetDefaultContentSetting(
 742                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
 743
 744   // Set preference to manage the default-content-setting for Plugins.
 745   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
 746                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 747   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 748             host_content_settings_map->GetDefaultContentSetting(
 749                 CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
 750
 751   // Remove the preference to manage the default-content-setting for Plugins.
 752   prefs->RemoveManagedPref(prefs::kManagedDefaultPluginsSetting);
 753   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 754             host_content_settings_map->GetDefaultContentSetting(
 755                 CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
 756 }
 757
 758 TEST_F(HostContentSettingsMapTest,
 759        GetNonDefaultContentSettingsIfTypeManaged) {
 760   TestingProfile profile;
 761   HostContentSettingsMap* host_content_settings_map =
 762       profile.GetHostContentSettingsMap();
 763   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 764
 765   // Set pattern for JavaScript setting.
 766   ContentSettingsPattern pattern =
 767        ContentSettingsPattern::FromString("[*.]example.com");
 768   host_content_settings_map->SetContentSetting(
 769       pattern,
 770       ContentSettingsPattern::Wildcard(),
 771       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 772       std::string(),
 773       CONTENT_SETTING_BLOCK);
 774
 775   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 776             host_content_settings_map->GetDefaultContentSetting(
 777                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
 778
 779   GURL host("http://example.com/");
 780   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 781             host_content_settings_map->GetContentSetting(
 782                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 783
 784   // Set managed-default-content-setting for content-settings-type JavaScript.
 785   prefs->SetManagedPref(prefs::kManagedDefaultJavaScriptSetting,
 786                         new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 787   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 788             host_content_settings_map->GetContentSetting(
 789                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 790 }
 791
 792 // Managed default content setting should have higher priority
 793 // than user defined patterns.
 794 TEST_F(HostContentSettingsMapTest,
 795        ManagedDefaultContentSettingIgnoreUserPattern) {
 796   TestingProfile profile;
 797   HostContentSettingsMap* host_content_settings_map =
 798       profile.GetHostContentSettingsMap();
 799   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 800
 801   // Block all JavaScript.
 802   host_content_settings_map->SetDefaultContentSetting(
 803       CONTENT_SETTINGS_TYPE_JAVASCRIPT, CONTENT_SETTING_BLOCK);
 804
 805   // Set an exception to allow "[*.]example.com"
 806   ContentSettingsPattern pattern =
 807       ContentSettingsPattern::FromString("[*.]example.com");
 808
 809   host_content_settings_map->SetContentSetting(
 810       pattern,
 811       ContentSettingsPattern::Wildcard(),
 812       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 813       std::string(),
 814       CONTENT_SETTING_ALLOW);
 815
 816   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 817             host_content_settings_map->GetDefaultContentSetting(
 818                 CONTENT_SETTINGS_TYPE_JAVASCRIPT, NULL));
 819   GURL host("http://example.com/");
 820   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 821             host_content_settings_map->GetContentSetting(
 822                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 823
 824   // Set managed-default-content-settings-preferences.
 825   prefs->SetManagedPref(prefs::kManagedDefaultJavaScriptSetting,
 826                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 827   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 828             host_content_settings_map->GetContentSetting(
 829                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 830
 831   // Remove managed-default-content-settings-preferences.
 832   prefs->RemoveManagedPref(prefs::kManagedDefaultJavaScriptSetting);
 833   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 834             host_content_settings_map->GetContentSetting(
 835                 host, host, CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string()));
 836 }
 837
 838 // If a default-content-setting is set to managed setting, the user defined
 839 // setting should be preserved.
 840 TEST_F(HostContentSettingsMapTest, OverwrittenDefaultContentSetting) {
 841   TestingProfile profile;
 842   HostContentSettingsMap* host_content_settings_map =
 843       profile.GetHostContentSettingsMap();
 844   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 845
 846   // Set user defined default-content-setting for Cookies.
 847   host_content_settings_map->SetDefaultContentSetting(
 848       CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_BLOCK);
 849   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 850             host_content_settings_map->GetDefaultContentSetting(
 851                 CONTENT_SETTINGS_TYPE_COOKIES, NULL));
 852
 853   // Set preference to manage the default-content-setting for Cookies.
 854   prefs->SetManagedPref(prefs::kManagedDefaultCookiesSetting,
 855                         new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 856   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 857             host_content_settings_map->GetDefaultContentSetting(
 858                 CONTENT_SETTINGS_TYPE_COOKIES, NULL));
 859
 860   // Remove the preference to manage the default-content-setting for Cookies.
 861   prefs->RemoveManagedPref(prefs::kManagedDefaultCookiesSetting);
 862   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 863             host_content_settings_map->GetDefaultContentSetting(
 864                 CONTENT_SETTINGS_TYPE_COOKIES, NULL));
 865 }
 866
 867 // If a setting for a default-content-setting-type is set while the type is
 868 // managed, then the new setting should be preserved and used after the
 869 // default-content-setting-type is not managed anymore.
 870 TEST_F(HostContentSettingsMapTest, SettingDefaultContentSettingsWhenManaged) {
 871   TestingProfile profile;
 872   HostContentSettingsMap* host_content_settings_map =
 873       profile.GetHostContentSettingsMap();
 874   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 875
 876   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
 877                         new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 878   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 879             host_content_settings_map->GetDefaultContentSetting(
 880                 CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
 881
 882   host_content_settings_map->SetDefaultContentSetting(
 883       CONTENT_SETTINGS_TYPE_PLUGINS, CONTENT_SETTING_BLOCK);
 884   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 885             host_content_settings_map->GetDefaultContentSetting(
 886                 CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
 887
 888   prefs->RemoveManagedPref(prefs::kManagedDefaultPluginsSetting);
 889   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 890             host_content_settings_map->GetDefaultContentSetting(
 891                 CONTENT_SETTINGS_TYPE_PLUGINS, NULL));
 892 }
 893
 894 TEST_F(HostContentSettingsMapTest, GetContentSetting) {
 895   TestingProfile profile;
 896   HostContentSettingsMap* host_content_settings_map =
 897       profile.GetHostContentSettingsMap();
 898
 899   GURL host("http://example.com/");
 900   GURL embedder("chrome://foo");
 901   ContentSettingsPattern pattern =
 902        ContentSettingsPattern::FromString("[*.]example.com");
 903   host_content_settings_map->SetContentSetting(
 904       pattern,
 905       ContentSettingsPattern::Wildcard(),
 906       CONTENT_SETTINGS_TYPE_IMAGES,
 907       std::string(),
 908       CONTENT_SETTING_BLOCK);
 909   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 910             host_content_settings_map->GetContentSetting(
 911                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 912   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 913             host_content_settings_map->GetContentSetting(
 914                 embedder, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
 915 }
 916
 917 TEST_F(HostContentSettingsMapTest, ShouldAllowAllContent) {
 918   TestingProfile profile;
 919   HostContentSettingsMap* host_content_settings_map =
 920       profile.GetHostContentSettingsMap();
 921
 922   GURL http_host("http://example.com/");
 923   GURL https_host("https://example.com/");
 924   GURL embedder("chrome://foo");
 925   GURL extension("chrome-extension://foo");
 926   EXPECT_FALSE(host_content_settings_map->ShouldAllowAllContent(
 927                    http_host, embedder, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
 928   EXPECT_FALSE(host_content_settings_map->ShouldAllowAllContent(
 929                    http_host, embedder, CONTENT_SETTINGS_TYPE_GEOLOCATION));
 930   EXPECT_FALSE(host_content_settings_map->ShouldAllowAllContent(
 931                    http_host, embedder, CONTENT_SETTINGS_TYPE_COOKIES));
 932   EXPECT_TRUE(host_content_settings_map->ShouldAllowAllContent(
 933                   https_host, embedder, CONTENT_SETTINGS_TYPE_COOKIES));
 934   EXPECT_TRUE(host_content_settings_map->ShouldAllowAllContent(
 935                   https_host, embedder, CONTENT_SETTINGS_TYPE_COOKIES));
 936   EXPECT_TRUE(host_content_settings_map->ShouldAllowAllContent(
 937                   embedder, http_host, CONTENT_SETTINGS_TYPE_COOKIES));
 938   EXPECT_TRUE(host_content_settings_map->ShouldAllowAllContent(
 939                   extension, extension, CONTENT_SETTINGS_TYPE_COOKIES));
 940   EXPECT_FALSE(host_content_settings_map->ShouldAllowAllContent(
 941                    extension, extension, CONTENT_SETTINGS_TYPE_PLUGINS));
 942   EXPECT_FALSE(host_content_settings_map->ShouldAllowAllContent(
 943                    extension, http_host, CONTENT_SETTINGS_TYPE_COOKIES));
 944 }
 945
 946 TEST_F(HostContentSettingsMapTest, MigrateClearOnExit) {
 947   TestingProfile profile;
 948   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 949
 950   prefs->SetBoolean(prefs::kClearSiteDataOnExit, true);
 951
 952   scoped_ptr<base::Value> patterns(base::JSONReader::Read(
 953       "{\"[*.]example.com,*\":{\"cookies\": 1},"
 954       " \"[*.]other.com,*\":{\"cookies\": 2},"
 955       " \"[*.]third.com,*\":{\"cookies\": 4}}"));
 956   profile.GetPrefs()->Set(prefs::kContentSettingsPatternPairs, *patterns);
 957
 958   scoped_ptr<base::Value> defaults(base::JSONReader::Read("{\"cookies\": 1}"));
 959   profile.GetPrefs()->Set(prefs::kDefaultContentSettings, *defaults);
 960
 961   HostContentSettingsMap* host_content_settings_map =
 962       profile.GetHostContentSettingsMap();
 963
 964   EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
 965             host_content_settings_map->GetDefaultContentSetting(
 966                 CONTENT_SETTINGS_TYPE_COOKIES, NULL));
 967   EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
 968             host_content_settings_map->GetContentSetting(
 969                 GURL("http://example.com"),
 970                 GURL("http://example.com"),
 971                 CONTENT_SETTINGS_TYPE_COOKIES,
 972                 std::string()));
 973   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 974             host_content_settings_map->GetContentSetting(
 975                 GURL("http://other.com"),
 976                 GURL("http://other.com"),
 977                 CONTENT_SETTINGS_TYPE_COOKIES,
 978                 std::string()));
 979   EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
 980             host_content_settings_map->GetContentSetting(
 981                 GURL("http://third.com"),
 982                 GURL("http://third.com"),
 983                 CONTENT_SETTINGS_TYPE_COOKIES,
 984                 std::string()));
 985 }
 986
 987 TEST_F(HostContentSettingsMapTest, AddContentSettingsObserver) {
 988   TestingProfile profile;
 989   HostContentSettingsMap* host_content_settings_map =
 990       profile.GetHostContentSettingsMap();
 991   content_settings::MockObserver mock_observer;
 992
 993   GURL host("http://example.com/");
 994   ContentSettingsPattern pattern =
 995       ContentSettingsPattern::FromString("[*.]example.com");
 996   EXPECT_CALL(mock_observer,
 997               OnContentSettingChanged(pattern,
 998                                       ContentSettingsPattern::Wildcard(),
 999                                       CONTENT_SETTINGS_TYPE_IMAGES,
1000                                       ""));
1001
1002   host_content_settings_map->AddObserver(&mock_observer);
1003
1004   EXPECT_EQ(CONTENT_SETTING_ALLOW,
1005             host_content_settings_map->GetContentSetting(
1006                 host, host, CONTENT_SETTINGS_TYPE_IMAGES, std::string()));
1007   host_content_settings_map->SetContentSetting(
1008       pattern,
1009       ContentSettingsPattern::Wildcard(),
1010       CONTENT_SETTINGS_TYPE_IMAGES,
1011       std::string(),
1012       CONTENT_SETTING_DEFAULT);
1013 }