[Policy Experimental] Add policies to allow Cookies and Pop-ups exceptions.

chrome/browser/content_settings/host_content_settings_map_unittest.cc

 // Copyright (c) 2012 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 "base/message_loop/message_loop.h"
 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/mock_settings_observer.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/content_settings_details.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/browser/website_settings_info.h"
 #include "components/content_settings/core/browser/website_settings_registry.h"
 #include "components/content_settings/core/common/pref_names.h"
+#include "components/content_settings/core/test/content_settings_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/static_cookie_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
@@ skipping 734 matching lines @@
   scoped_ptr<base::Value> stored_value =
       host_content_settings_map->GetWebsiteSetting(
           host, host, CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA, std::string(),
           nullptr);
   EXPECT_TRUE(stored_value && stored_value->Equals(&test_value));
   EXPECT_EQ(nullptr, otr_map->GetWebsiteSetting(
                          host, host, CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA,
                          std::string(), nullptr));
 }
 
+TEST_F(HostContentSettingsMapTest, AreUserExceptionsAllowedForType) {
+  struct {
+    ContentSettingsType content_type;
+    const char* policy_default_setting;
+    const char* pref_exception_setting;
+  } kTypeInfos[] = {
+    {CONTENT_SETTINGS_TYPE_COOKIES, prefs::kManagedDefaultCookiesSetting,
+     prefs::kUserCookiesExceptionsUsage},
+    {CONTENT_SETTINGS_TYPE_POPUPS, prefs::kManagedDefaultPopupsSetting,
+     prefs::kUserPopupsExceptionsUsage},
+  };
+
+  TestingProfile profile;
+  syncable_prefs::TestingPrefServiceSyncable* prefs =
+      profile.GetTestingPrefService();
+  HostContentSettingsMap* host_content_settings_map =
+      HostContentSettingsMapFactory::GetForProfile(&profile);
+
+  for (const auto& type_info : kTypeInfos) {
+    // Lambdas to simplify setting valuesfor current test case.
+    auto clear_policy_default = [&]() {
+      prefs->RemoveManagedPref(type_info.policy_default_setting);
+    };
+    auto set_policy_default = [&](ContentSetting setting) {
+      prefs->SetManagedPref(type_info.policy_default_setting,
+                            new base::FundamentalValue(setting));
+    };
+    auto clear_allow_user_exceptions = [&]() {
+      prefs->RemoveManagedPref(type_info.pref_exception_setting);
+    };
+    auto set_allow_user_exceptions = [&](ContentSetting setting) {
+      prefs->SetManagedPref(type_info.pref_exception_setting,
+                            new base::FundamentalValue(setting));
+    };
+
+    // Main function to test: Can user edit pref exceptions?
+    auto maybe_enable_pref_exceptions = [&]()->bool {
+      return host_content_settings_map->AreUserExceptionsAllowedForType(
+          type_info.content_type);
+    };
+
+    // No settings: Yes.
+    clear_allow_user_exceptions();
+    clear_policy_default();
+    EXPECT_TRUE(maybe_enable_pref_exceptions());
+
+    // Policy enforces default value: No.
+    set_policy_default(CONTENT_SETTING_ALLOW);
+    EXPECT_FALSE(maybe_enable_pref_exceptions());
+    set_policy_default(CONTENT_SETTING_BLOCK);
+    EXPECT_FALSE(maybe_enable_pref_exceptions());
+
+    // Allow exceptions: Yes, regardless of policy default.
+    set_allow_user_exceptions(CONTENT_SETTING_ALLOW);
+    clear_policy_default();
+    EXPECT_TRUE(maybe_enable_pref_exceptions());
+    set_policy_default(CONTENT_SETTING_ALLOW);
+    EXPECT_TRUE(maybe_enable_pref_exceptions());
+    set_policy_default(CONTENT_SETTING_BLOCK);
+    EXPECT_TRUE(maybe_enable_pref_exceptions());
+
+    // Block exceptions: No, regardless of policy default.
+    set_allow_user_exceptions(CONTENT_SETTING_BLOCK);
+    clear_policy_default();
+    EXPECT_FALSE(maybe_enable_pref_exceptions());
+    set_policy_default(CONTENT_SETTING_ALLOW);
+    EXPECT_FALSE(maybe_enable_pref_exceptions());
+    set_policy_default(CONTENT_SETTING_BLOCK);
+    EXPECT_FALSE(maybe_enable_pref_exceptions());
+
+    // Not bothering caller clear_default() for this case; let it set.
+  }
+}
+
+TEST_F(HostContentSettingsMapTest, PrefExceptionsOperation) {
+  using content_settings::TestUtils;
+  // Arbitrarily using cookies as content type to test.
+  const ContentSettingsType kContentType = CONTENT_SETTINGS_TYPE_COOKIES;
+  const char* kPolicyDefaultSetting = prefs::kManagedDefaultCookiesSetting;
+  const char* kUserExceptionsUsage = prefs::kUserCookiesExceptionsUsage;
+  const char kUrlUserException[] = "http://user_except.com";
+  const char kUrlNonUserException[] = "http://non_user_except.com";
+
+  TestingProfile profile;
+  syncable_prefs::TestingPrefServiceSyncable* prefs =
+      profile.GetTestingPrefService();
+  HostContentSettingsMap* host_content_settings_map =
+      HostContentSettingsMapFactory::GetForProfile(&profile);
+
+  // Helpers to change policy settings.
+  auto clear_policy_default = [&]() {
+    prefs->RemoveManagedPref(kPolicyDefaultSetting);
+  };
+  auto set_policy_default = [&](ContentSetting setting) {
+    prefs->SetManagedPref(kPolicyDefaultSetting,
+                          new base::FundamentalValue(setting));
+  };
+  auto clear_allow_user_exceptions = [&]() {
+    prefs->RemoveManagedPref(kUserExceptionsUsage);
+  };
+  auto set_allow_user_exceptions = [&](ContentSetting setting) {
+    prefs->SetManagedPref(kUserExceptionsUsage,
+                          new base::FundamentalValue(setting));
+  };
+
+  // Wrapper to query GetWebsiteSetting(), and get the source.
+  auto get_source = [&](const std::string& url_str) ->
+      content_settings::SettingSource {
+    GURL host(url_str);
+    content_settings::SettingInfo setting_info;
+    scoped_ptr<base::Value> result =
+        host_content_settings_map->GetWebsiteSetting(
+            host, host, kContentType, std::string(),
+            &setting_info);
+    return setting_info.source;
+  };
+
+  // Add user exception.
+  TestUtils::AddPrefException(kUrlUserException, kContentType,
+      CONTENT_SETTING_ALLOW, host_content_settings_map);
+
+  using content_settings::SETTING_SOURCE_POLICY;
+  using content_settings::SETTING_SOURCE_USER;
+
+  // No policy setting: follow users settings.
+  clear_allow_user_exceptions();
+  clear_policy_default();
+  // User exceptions.
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlUserException));
+  // User default.
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlNonUserException));
+
+  // Policy overrids users always.
+  set_policy_default(CONTENT_SETTING_ALLOW);
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+  set_policy_default(CONTENT_SETTING_BLOCK);
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+
+  // Allow exceptions: user if exception found, else policy default (if set).
+  set_allow_user_exceptions(CONTENT_SETTING_ALLOW);
+  clear_policy_default();
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlNonUserException));
+  set_policy_default(CONTENT_SETTING_ALLOW);
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+  set_policy_default(CONTENT_SETTING_BLOCK);
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+
+  // Block exceptions: policy overrides users always, and when policy is not
+  // set, user default catches everything.
+  set_allow_user_exceptions(CONTENT_SETTING_BLOCK);
+  clear_policy_default();
+  // User default -- unfortunately kProviderNamesSourceMap makes it ambiguous.
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlUserException));
+  // User default.
+  EXPECT_EQ(SETTING_SOURCE_USER, get_source(kUrlNonUserException));
+  set_policy_default(CONTENT_SETTING_ALLOW);
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+  set_policy_default(CONTENT_SETTING_BLOCK);
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlUserException));
+  EXPECT_EQ(SETTING_SOURCE_POLICY, get_source(kUrlNonUserException));
+}
+
 // For a single Unicode encoded pattern, check if it gets converted to punycode
 // and old pattern gets deleted.
 TEST_F(HostContentSettingsMapTest, CanonicalizeExceptionsUnicodeOnly) {
   TestingProfile profile;
   PrefService* prefs = profile.GetPrefs();
 
   // Set utf-8 data.
   {
     DictionaryPrefUpdate update(prefs,
                                 GetPrefName(CONTENT_SETTINGS_TYPE_PLUGINS));
@@ skipping 398 matching lines @@
                 host, host, CONTENT_SETTINGS_TYPE_KEYGEN, std::string()));
 
   // After migrating old settings, changes to the setting works.
   host_content_settings_map->SetContentSettingDefaultScope(
       host, GURL(), CONTENT_SETTINGS_TYPE_KEYGEN, std::string(),
       CONTENT_SETTING_BLOCK);
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 host, host, CONTENT_SETTINGS_TYPE_KEYGEN, std::string()));
 }