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

components/content_settings/core/browser/content_settings_policy_provider.cc

Index: components/content_settings/core/browser/content_settings_policy_provider.cc
diff --git a/components/content_settings/core/browser/content_settings_policy_provider.cc b/components/content_settings/core/browser/content_settings_policy_provider.cc
index d8d1b831e6139ad04347a859550e20777ed3d101..f96676d1ba045f311f003969a0a501181e9f6bdf 100644
--- a/components/content_settings/core/browser/content_settings_policy_provider.cc
+++ b/components/content_settings/core/browser/content_settings_policy_provider.cc
@@ -60,6 +60,17 @@ const PrefsForManagedContentSettingsMapEntry
         {prefs::kManagedKeygenBlockedForUrls,
          CONTENT_SETTINGS_TYPE_KEYGEN, CONTENT_SETTING_BLOCK}};
 
+struct PrefsForManagedExceptionsSettingsMapEntry {
+  const char* pref_name;
+  ContentSettingsType content_type;
+};
+
+const PrefsForManagedExceptionsSettingsMapEntry
+    KPrefsForManagedExceptionsSettingsMap[] = {
+        {prefs::kUserCookiesExceptionsUsage, CONTENT_SETTINGS_TYPE_COOKIES},
+        {prefs::kUserPopupsExceptionsUsage, CONTENT_SETTINGS_TYPE_POPUPS}
+};
+
 }  // namespace
 
 namespace content_settings {
@@ -112,8 +123,9 @@ void PolicyProvider::RegisterProfilePrefs(
   registry->RegisterListPref(prefs::kManagedPopupsBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedKeygenAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedKeygenBlockedForUrls);
-  // Preferences for default content setting policies. If a policy is not set of
-  // the corresponding preferences below is set to CONTENT_SETTING_DEFAULT.
+
+  // Preferences for default content setting policies. If a policy is not set
+  // then the corresponding preferences becomes CONTENT_SETTING_DEFAULT.
   registry->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultGeolocationSetting,
@@ -134,10 +146,18 @@ void PolicyProvider::RegisterProfilePrefs(
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultWebBluetoothGuardSetting,
                                 CONTENT_SETTING_DEFAULT);
+
+  // Preferences for content setting exception policies. If a policy is not set
+  // then the corresponding preferences becomes CONTENT_SETTING_DEFAULT.
+  registry->RegisterIntegerPref(prefs::kUserCookiesExceptionsUsage,
+                                CONTENT_SETTING_DEFAULT);
+  registry->RegisterIntegerPref(prefs::kUserPopupsExceptionsUsage,
+                                CONTENT_SETTING_DEFAULT);
 }
 
 PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   ReadManagedDefaultSettings();
+  ReadUserExceptionsUsageSettings();
   ReadManagedContentSettings(false);
 
   pref_change_registrar_.Init(prefs_);
@@ -163,6 +183,7 @@ PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   pref_change_registrar_.Add(prefs::kManagedPopupsBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedKeygenAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedKeygenBlockedForUrls, callback);
+
   // The following preferences are only used to indicate if a default content
   // setting is managed and to hold the managed default setting value. If the
   // value for any of the following preferences is set then the corresponding
@@ -184,6 +205,11 @@ PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   pref_change_registrar_.Add(prefs::kManagedDefaultKeygenSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultWebBluetoothGuardSetting,
                              callback);
+
+  // User exceptions usage policies, which dictates whether user can set
+  // exceptions that overrides policy defaults content settings.
+  pref_change_registrar_.Add(prefs::kUserCookiesExceptionsUsage, callback);
+  pref_change_registrar_.Add(prefs::kUserPopupsExceptionsUsage, callback);
 }
 
 PolicyProvider::~PolicyProvider() {
@@ -336,6 +362,29 @@ void PolicyProvider::ReadManagedDefaultSettings() {
     UpdateManagedDefaultSetting(entry);
 }
 
+void PolicyProvider::ReadUserExceptionsUsageSettings() {
+  user_exceptions_usage_settings_map_.clear();
+
+  for (const PrefsForManagedExceptionsSettingsMapEntry& entry :
+       KPrefsForManagedExceptionsSettingsMap) {
+    if (!prefs_->HasPrefPath(entry.pref_name))
+      continue;

[Bernhard Bauer, 2016/04/08 14:44:35]

My previous comment still applies here.

[huangs, 2016/04/11 19:01:03]

Oh I see; I missed "if it's not set by policy, it will have the default value". 
Removed.

+    // If pref is set then it must be managed, but exclude non-managed anyway.
+    if (!prefs_->IsManagedPreference(entry.pref_name))
+      continue;
+
+    ContentSetting content_settings =
+        IntToContentSetting(prefs_->GetInteger(entry.pref_name));
+
+    if (content_settings == CONTENT_SETTING_DEFAULT) {
+      user_exceptions_usage_settings_map_.erase(entry.content_type);

[Bernhard Bauer, 2016/04/08 14:44:35]

This shouldn't be necessary if we clear the map in advance, no?

[huangs, 2016/04/11 19:01:03]

Removed.  The code is in flux: If we don't need to worry about wildcard then we
can make |user_exceptions_usage_settings_map_| an std::set instead (|..._set_|);
and if we do then we'd see more cases.

+    } else {
+      user_exceptions_usage_settings_map_[entry.content_type] =
+          content_settings;
+    }
+  }
+}
+
 void PolicyProvider::UpdateManagedDefaultSetting(
     const PrefsForManagedDefaultMapEntry& entry) {
   // If a pref to manage a default-content-setting was not set (NOTICE:
@@ -360,7 +409,6 @@ void PolicyProvider::UpdateManagedDefaultSetting(
   }
 }
 
-
 void PolicyProvider::ReadManagedContentSettings(bool overwrite) {
   base::AutoLock auto_lock(lock_);
   if (overwrite)
@@ -393,6 +441,13 @@ void PolicyProvider::ShutdownOnUIThread() {
   prefs_ = nullptr;
 }
 
+ContentSetting PolicyProvider::GetUserExceptionsUsageSettingForType(
+    ContentSettingsType content_type) const {
+  auto it = user_exceptions_usage_settings_map_.find(content_type);
+  return it == user_exceptions_usage_settings_map_.end() ?
+      CONTENT_SETTING_DEFAULT : it->second;
+}
+
 void PolicyProvider::OnPreferenceChanged(const std::string& name) {
   DCHECK(CalledOnValidThread());
 
@@ -419,6 +474,10 @@ void PolicyProvider::OnPreferenceChanged(const std::string& name) {
       name == prefs::kManagedKeygenBlockedForUrls) {
     ReadManagedContentSettings(true);
     ReadManagedDefaultSettings();
+
+  } else if (name == prefs::kUserCookiesExceptionsUsage ||
+      name == prefs::kUserPopupsExceptionsUsage) {
+    ReadUserExceptionsUsageSettings();
   }
 
   NotifyObservers(ContentSettingsPattern(),