Adding <keygen> Content Setting (core)

components/content_settings/core/browser/content_settings_policy_provider.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 "components/content_settings/core/browser/content_settings_policy_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
          CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW},
         {prefs::kManagedNotificationsBlockedForUrls,
          CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_BLOCK},
         {prefs::kManagedPluginsAllowedForUrls, CONTENT_SETTINGS_TYPE_PLUGINS,
          CONTENT_SETTING_ALLOW},
         {prefs::kManagedPluginsBlockedForUrls, CONTENT_SETTINGS_TYPE_PLUGINS,
          CONTENT_SETTING_BLOCK},
         {prefs::kManagedPopupsAllowedForUrls, CONTENT_SETTINGS_TYPE_POPUPS,
          CONTENT_SETTING_ALLOW},
         {prefs::kManagedPopupsBlockedForUrls, CONTENT_SETTINGS_TYPE_POPUPS,
-         CONTENT_SETTING_BLOCK}};
+         CONTENT_SETTING_BLOCK},
+        {prefs::kManagedKeygenAllowedForUrls,
+         CONTENT_SETTINGS_TYPE_KEYGEN, CONTENT_SETTING_ALLOW},
+        {prefs::kManagedKeygenBlockedForUrls,
+         CONTENT_SETTINGS_TYPE_KEYGEN, CONTENT_SETTING_BLOCK}};
 
 }  // namespace
 
 namespace content_settings {
 
 // The preferences used to manage the default policy value for
 // ContentSettingsTypes.
 struct PolicyProvider::PrefsForManagedDefaultMapEntry {
   ContentSettingsType content_type;
   const char* pref_name;
 };
 
 // static
 const PolicyProvider::PrefsForManagedDefaultMapEntry
     PolicyProvider::kPrefsForManagedDefault[] = {
         {CONTENT_SETTINGS_TYPE_COOKIES, prefs::kManagedDefaultCookiesSetting},
         {CONTENT_SETTINGS_TYPE_IMAGES, prefs::kManagedDefaultImagesSetting},
         {CONTENT_SETTINGS_TYPE_GEOLOCATION,
          prefs::kManagedDefaultGeolocationSetting},
         {CONTENT_SETTINGS_TYPE_JAVASCRIPT,
          prefs::kManagedDefaultJavaScriptSetting},
         {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
          prefs::kManagedDefaultMediaStreamSetting},
         {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
          prefs::kManagedDefaultMediaStreamSetting},
         {CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
          prefs::kManagedDefaultNotificationsSetting},
         {CONTENT_SETTINGS_TYPE_PLUGINS, prefs::kManagedDefaultPluginsSetting},
         {CONTENT_SETTINGS_TYPE_POPUPS, prefs::kManagedDefaultPopupsSetting},
+        {CONTENT_SETTINGS_TYPE_KEYGEN,
+         prefs::kManagedDefaultKeygenSetting},

[msramek, 2015/11/06 16:56:15]

nit: This fits on a line.

[svaldez, 2015/11/06 21:30:07]

Done.

 };
 
 // static
 void PolicyProvider::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(prefs::kManagedAutoSelectCertificateForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesSessionOnlyForUrls);
   registry->RegisterListPref(prefs::kManagedImagesAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedImagesBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedJavaScriptAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedJavaScriptBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedNotificationsAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedNotificationsBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedPluginsAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedPluginsBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedPopupsAllowedForUrls);
   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.
   registry->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultGeolocationSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultImagesSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultJavaScriptSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultNotificationsSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultMediaStreamSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultPluginsSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultPopupsSetting,
                                 CONTENT_SETTING_DEFAULT);
+  registry->RegisterIntegerPref(prefs::kManagedDefaultKeygenSetting,
+                                CONTENT_SETTING_DEFAULT);
 }
 
 PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   ReadManagedDefaultSettings();
   ReadManagedContentSettings(false);
 
   pref_change_registrar_.Init(prefs_);
   PrefChangeRegistrar::NamedChangeCallback callback =
       base::Bind(&PolicyProvider::OnPreferenceChanged, base::Unretained(this));
   pref_change_registrar_.Add(
       prefs::kManagedAutoSelectCertificateForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedCookiesAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedCookiesBlockedForUrls, callback);
   pref_change_registrar_.Add(
       prefs::kManagedCookiesSessionOnlyForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedImagesAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedImagesBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptBlockedForUrls, callback);
-
   pref_change_registrar_.Add(
       prefs::kManagedNotificationsAllowedForUrls, callback);
   pref_change_registrar_.Add(
       prefs::kManagedNotificationsBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPluginsAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPluginsBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPopupsAllowedForUrls, callback);
   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
   // default content setting is managed. These preferences exist in parallel to
   // the preference default content settings. If a default content settings type
   // is managed any user defined exceptions (patterns) for this type are
   // ignored.
   pref_change_registrar_.Add(prefs::kManagedDefaultCookiesSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultGeolocationSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultImagesSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultJavaScriptSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultNotificationsSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultMediaStreamSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultPluginsSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultPopupsSetting, callback);
+  pref_change_registrar_.Add(prefs::kManagedDefaultKeygenSetting, callback);
 }
 
 PolicyProvider::~PolicyProvider() {
   DCHECK(!prefs_);
 }
 
 RuleIterator* PolicyProvider::GetRuleIterator(
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     bool incognito) const {
@@ skipping 210 matching lines @@
       name == prefs::kManagedCookiesSessionOnlyForUrls ||
       name == prefs::kManagedImagesAllowedForUrls ||
       name == prefs::kManagedImagesBlockedForUrls ||
       name == prefs::kManagedJavaScriptAllowedForUrls ||
       name == prefs::kManagedJavaScriptBlockedForUrls ||
       name == prefs::kManagedNotificationsAllowedForUrls ||
       name == prefs::kManagedNotificationsBlockedForUrls ||
       name == prefs::kManagedPluginsAllowedForUrls ||
       name == prefs::kManagedPluginsBlockedForUrls ||
       name == prefs::kManagedPopupsAllowedForUrls ||
-      name == prefs::kManagedPopupsBlockedForUrls) {
+      name == prefs::kManagedPopupsBlockedForUrls ||
+      name == prefs::kManagedKeygenAllowedForUrls ||
+      name == prefs::kManagedKeygenBlockedForUrls) {
     ReadManagedContentSettings(true);
     ReadManagedDefaultSettings();
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   CONTENT_SETTINGS_TYPE_DEFAULT,
                   std::string());
 }
 
 }  // namespace content_settings