[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..6c97fc5a181b150237cc49c11486fd1905e9bdc4 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 PrefsForManagedExceptionSettingsMapEntry {
+  const char* pref_name;
+  ContentSettingsType content_type;
+};
+
+const PrefsForManagedExceptionSettingsMapEntry
+    KPrefsForManagedExceptionSettingsSMap[] = {

[Bernhard Bauer, 2016/04/07 15:30:13]

kPrefsForManagedExceptionSettingsMap

[huangs, 2016/04/07 21:44:06]

Done.

+        {prefs::kPrefExceptionsUsageCookies, CONTENT_SETTINGS_TYPE_COOKIES},
+        {prefs::kPrefExceptionsUsagePopups, 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::kPrefExceptionsUsageCookies,
+                                CONTENT_SETTING_DEFAULT);
+  registry->RegisterIntegerPref(prefs::kPrefExceptionsUsagePopups,
+                                CONTENT_SETTING_DEFAULT);
 }
 
 PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   ReadManagedDefaultSettings();
+  ReadUserExceptionsAllowed();
   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);
+
+  // Managed exception policies, which enables preference exceptions to to be
+  // set, and override defaults content settings set by policy.
+  pref_change_registrar_.Add(prefs::kPrefExceptionsUsageCookies, callback);
+  pref_change_registrar_.Add(prefs::kPrefExceptionsUsagePopups, callback);
 }
 
 PolicyProvider::~PolicyProvider() {
@@ -336,6 +362,31 @@ void PolicyProvider::ReadManagedDefaultSettings() {
     UpdateManagedDefaultSetting(entry);
 }
 
+void PolicyProvider::ReadUserExceptionsAllowed() {
+  for (const PrefsForManagedExceptionSettingsMapEntry& entry :
+       KPrefsForManagedExceptionSettingsSMap) {
+    if (!prefs_->HasPrefPath(entry.pref_name)) {

[Bernhard Bauer, 2016/04/07 15:30:13]

This is unnecessary -- We know that the preference can't be set by the user, and
if it's not set by policy, it will have the default value, which we handle
below.

[huangs, 2016/04/07 21:44:06]

Did this to allow incremental changes to |user_exceptions_allowed_map_| -- but
to follow what's done for |value_map_|, I should just clear
|user_exceptions_allowed_map_| beforehand.  Done.

+      user_exceptions_allowed_map_.erase(entry.content_type);
+      continue;
+    }
+    // If pref is set then it must be managed, but exclude non-managed anyway.
+    if (!prefs_->IsManagedPreference(entry.pref_name))
+      continue;
+
+    const PrefService::Preference* pref =
+        prefs_->FindPreference(entry.pref_name);
+    DCHECK(pref);
+    DCHECK_EQ(base::Value::TYPE_INTEGER, pref->GetValue()->GetType());
+    ContentSetting content_settings =
+        content_settings::ValueToContentSetting(pref->GetValue());

[Bernhard Bauer, 2016/04/07 15:30:13]

Just use prefs_->GetInteger(entry.pref_name).

[huangs, 2016/04/07 21:44:06]

Also need content_settings::IntToContentSetting(). Done.

+    if (content_settings == CONTENT_SETTING_DEFAULT) {
+      user_exceptions_allowed_map_.erase(entry.content_type);
+    } else {
+      user_exceptions_allowed_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 +411,6 @@ void PolicyProvider::UpdateManagedDefaultSetting(
   }
 }
 
-
 void PolicyProvider::ReadManagedContentSettings(bool overwrite) {
   base::AutoLock auto_lock(lock_);
   if (overwrite)
@@ -393,6 +443,13 @@ void PolicyProvider::ShutdownOnUIThread() {
   prefs_ = nullptr;
 }
 
+ContentSetting PolicyProvider::AllowUserExceptionsForType(
+    ContentSettingsType content_type) const {
+  auto it = user_exceptions_allowed_map_.find(content_type);
+  return it == user_exceptions_allowed_map_.end() ?
+      CONTENT_SETTING_DEFAULT : it->second;
+}
+
 void PolicyProvider::OnPreferenceChanged(const std::string& name) {
   DCHECK(CalledOnValidThread());
 
@@ -419,6 +476,11 @@ void PolicyProvider::OnPreferenceChanged(const std::string& name) {
       name == prefs::kManagedKeygenBlockedForUrls) {
     ReadManagedContentSettings(true);
     ReadManagedDefaultSettings();
+  } else if (name == prefs::kPrefExceptionsUsageCookies ||
+      name == prefs::kPrefExceptionsUsagePopups) {
+    ReadUserExceptionsAllowed();
+    ReadManagedContentSettings(true);

[Bernhard Bauer, 2016/04/07 15:30:13]

Why do we read managed content settings again in this case?

[huangs, 2016/04/07 21:44:06]

Ah yes; we're not modifying them.  Removed.

+    ReadManagedDefaultSettings();
   }
 
   NotifyObservers(ContentSettingsPattern(),