HostContentSettingsMap refactoring.

chrome/browser/content_settings/host_content_settings_map_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
@@ skipping 299 matching lines @@
                                        CONTENT_SETTINGS_TYPE_IMAGES, false,
                                        _, _, true));
   host_content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_IMAGES, CONTENT_SETTING_BLOCK);
 }
 
 TEST_F(HostContentSettingsMapTest, ObserveDefaultPref) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
 
   PrefService* prefs = profile.GetPrefs();
 
   // Make a copy of the default pref value so we can reset it later.
   scoped_ptr<Value> default_value(prefs->FindPreference(
       prefs::kDefaultContentSettings)->GetValue()->DeepCopy());
 
   GURL host("http://example.com");
 
   host_content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_BLOCK);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(host, host, true));
 
   // Make a copy of the pref's new value so we can reset it later.
   scoped_ptr<Value> new_value(prefs->FindPreference(
       prefs::kDefaultContentSettings)->GetValue()->DeepCopy());
 
   // Clearing the backing pref should also clear the internal cache.
   prefs->Set(prefs::kDefaultContentSettings, *default_value);
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(host, host, true));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(host));
 
   // Reseting the pref to its previous value should update the cache.
   prefs->Set(prefs::kDefaultContentSettings, *new_value);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(host, host, true));
 }
 
 TEST_F(HostContentSettingsMapTest, ObserveExceptionPref) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
 
   PrefService* prefs = profile.GetPrefs();
 
   // Make a copy of the default pref value so we can reset it later.
   scoped_ptr<Value> default_value(prefs->FindPreference(
       prefs::kContentSettingsPatternPairs)->GetValue()->DeepCopy());
 
   ContentSettingsPattern pattern =
        ContentSettingsPattern::FromString("[*.]example.com");
   GURL host("http://example.com");
 
   host_content_settings_map->SetContentSetting(
       pattern,
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTINGS_TYPE_COOKIES,
       std::string(),
       CONTENT_SETTING_BLOCK);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+
+  EXPECT_FALSE(cookie_content_settings->Allow(host, host, true));
 
   // Make a copy of the pref's new value so we can reset it later.
   scoped_ptr<Value> new_value(prefs->FindPreference(
       prefs::kContentSettingsPatternPairs)->GetValue()->DeepCopy());
 
   // Clearing the backing pref should also clear the internal cache.
   prefs->Set(prefs::kContentSettingsPatternPairs, *default_value);
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(host, host, true));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(host));
 
   // Reseting the pref to its previous value should update the cache.
   prefs->Set(prefs::kContentSettingsPatternPairs, *new_value);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                host, host, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(host, host, true));
 }
 
 TEST_F(HostContentSettingsMapTest, HostTrimEndingDotCheck) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
 
   ContentSettingsPattern pattern =
        ContentSettingsPattern::FromString("[*.]example.com");
   GURL host_ending_with_dot("http://example.com./");
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 host_ending_with_dot,
                 host_ending_with_dot,
                 CONTENT_SETTINGS_TYPE_IMAGES,
@@ skipping 16 matching lines @@
       CONTENT_SETTINGS_TYPE_IMAGES,
       "",
       CONTENT_SETTING_BLOCK);
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 host_ending_with_dot,
                 host_ending_with_dot,
                 CONTENT_SETTINGS_TYPE_IMAGES,
                 ""));
 
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                host_ending_with_dot, host_ending_with_dot, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      host_ending_with_dot, host_ending_with_dot, true));
   host_content_settings_map->SetContentSetting(
       pattern,
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTINGS_TYPE_COOKIES,
       "",
       CONTENT_SETTING_DEFAULT);
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                host_ending_with_dot, host_ending_with_dot, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      host_ending_with_dot, host_ending_with_dot, true));
   host_content_settings_map->SetContentSetting(
       pattern,
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTINGS_TYPE_COOKIES,
       "",
       CONTENT_SETTING_BLOCK);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                host_ending_with_dot, host_ending_with_dot, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      host_ending_with_dot, host_ending_with_dot, true));
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 host_ending_with_dot,
                 host_ending_with_dot,
                 CONTENT_SETTINGS_TYPE_JAVASCRIPT,
                 ""));
   host_content_settings_map->SetContentSetting(
       pattern,
       ContentSettingsPattern::Wildcard(),
@@ skipping 616 matching lines @@
 // Tests for cookie content settings.
 const GURL kBlockedSite = GURL("http://ads.thirdparty.com");
 const GURL kAllowedSite = GURL("http://good.allays.com");
 const GURL kFirstPartySite = GURL("http://cool.things.com");
 const GURL kExtensionURL = GURL("chrome-extension://deadbeef");
 
 TEST_F(HostContentSettingsMapTest, CookiesBlockSingle) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
+
   host_content_settings_map->AddExceptionForURL(
       kBlockedSite,
       kBlockedSite,
       CONTENT_SETTINGS_TYPE_COOKIES,
       "",
       CONTENT_SETTING_BLOCK);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kBlockedSite, false));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kBlockedSite, false));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesBlockThirdParty) {
   TestingProfile profile;
-  HostContentSettingsMap* host_content_settings_map =
-      profile.GetHostContentSettingsMap();
-  host_content_settings_map->SetBlockThirdPartyCookies(true);
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
+  cookie_content_settings->SetBlockThirdPartyCookies(true);
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(kBlockedSite));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, true));
 
   CommandLine* cmd = CommandLine::ForCurrentProcess();
   AutoReset<CommandLine> auto_reset(cmd, *cmd);
   cmd->AppendSwitch(switches::kBlockReadingThirdPartyCookies);
 
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, true));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesAllowThirdParty) {
   TestingProfile profile;
-  HostContentSettingsMap* host_content_settings_map =
-      profile.GetHostContentSettingsMap();
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(kBlockedSite));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesExplicitBlockSingleThirdParty) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
   host_content_settings_map->AddExceptionForURL(
       kBlockedSite, kBlockedSite, CONTENT_SETTINGS_TYPE_COOKIES, "",
       CONTENT_SETTING_BLOCK);
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, true));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesExplicitSessionOnly) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
   host_content_settings_map->AddExceptionForURL(
       kBlockedSite, kBlockedSite, CONTENT_SETTINGS_TYPE_COOKIES, "",
       CONTENT_SETTING_SESSION_ONLY);
-  EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kBlockedSite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->EnforceSessionOnly(kBlockedSite));
 
-  host_content_settings_map->SetBlockThirdPartyCookies(true);
-  EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_SESSION_ONLY,
-            host_content_settings_map->GetCookieContentSetting(
-                kBlockedSite, kFirstPartySite, true));
+  cookie_content_settings->SetBlockThirdPartyCookies(true);
+  EXPECT_TRUE(cookie_content_settings->
+              Allow(kBlockedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->
+              Allow(kBlockedSite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->EnforceSessionOnly(kBlockedSite));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesThirdPartyBlockedExplicitAllow) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
   host_content_settings_map->AddExceptionForURL(
       kAllowedSite, kAllowedSite, CONTENT_SETTINGS_TYPE_COOKIES, "",
       CONTENT_SETTING_ALLOW);
-  host_content_settings_map->SetBlockThirdPartyCookies(true);
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, true));
+  cookie_content_settings->SetBlockThirdPartyCookies(true);
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(kAllowedSite));
 
   // Extensions should always be allowed to use cookies.
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kExtensionURL, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kExtensionURL, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kExtensionURL, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kExtensionURL, true));
 
   CommandLine* cmd = CommandLine::ForCurrentProcess();
   AutoReset<CommandLine> auto_reset(cmd, *cmd);
   cmd->AppendSwitch(switches::kBlockReadingThirdPartyCookies);
 
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(kAllowedSite));
 
   // Extensions should always be allowed to use cookies.
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kExtensionURL, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kExtensionURL, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kExtensionURL, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kExtensionURL, true));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesBlockEverything) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
   host_content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_BLOCK);
 
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kFirstPartySite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kFirstPartySite, kFirstPartySite, true));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kFirstPartySite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kFirstPartySite, kFirstPartySite, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, true));
 }
 
 TEST_F(HostContentSettingsMapTest, CookiesBlockEverythingExceptAllowed) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       profile.GetHostContentSettingsMap();
+  CookieContentSettings* cookie_content_settings =
+      profile.GetCookieContentSettings();
   host_content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_BLOCK);
   host_content_settings_map->AddExceptionForURL(
       kAllowedSite, kAllowedSite, CONTENT_SETTINGS_TYPE_COOKIES, "",
       CONTENT_SETTING_ALLOW);
 
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kFirstPartySite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_BLOCK,
-            host_content_settings_map->GetCookieContentSetting(
-                kFirstPartySite, kFirstPartySite, true));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kFirstPartySite, true));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kAllowedSite, false));
-  EXPECT_EQ(CONTENT_SETTING_ALLOW,
-            host_content_settings_map->GetCookieContentSetting(
-                kAllowedSite, kAllowedSite, true));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kFirstPartySite, kFirstPartySite, false));
+  EXPECT_FALSE(cookie_content_settings->Allow(
+      kFirstPartySite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kFirstPartySite, true));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kAllowedSite, false));
+  EXPECT_TRUE(cookie_content_settings->Allow(
+      kAllowedSite, kAllowedSite, true));
+  EXPECT_FALSE(cookie_content_settings->EnforceSessionOnly(kAllowedSite));
 }
 
 }  // namespace