Add new Content settings type AUTO-SUBMIT-CERTIFICATE

chrome/browser/content_settings/content_settings_policy_provider.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 "chrome/browser/content_settings/content_settings_policy_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 19 matching lines @@
 
 // The preferences used to manage ContentSettingsTypes.
 const char* kPrefToManageType[CONTENT_SETTINGS_NUM_TYPES] = {
   prefs::kManagedDefaultCookiesSetting,
   prefs::kManagedDefaultImagesSetting,
   prefs::kManagedDefaultJavaScriptSetting,
   prefs::kManagedDefaultPluginsSetting,
   prefs::kManagedDefaultPopupsSetting,
   prefs::kManagedDefaultGeolocationSetting,
   prefs::kManagedDefaultNotificationsSetting,
+  NULL,
+  prefs::kManagedDefaultAutoSelectCertificateSetting,
 };
 
 struct PrefsForManagedContentSettingsMapEntry {
   const char* pref_name;
   ContentSettingsType content_type;
   ContentSetting setting;
 };
 
 const PrefsForManagedContentSettingsMapEntry
     kPrefsForManagedContentSettingsMap[] = {
   {
+    prefs::kManagedAutoSelectCertificateForUrls,
+    CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
+    CONTENT_SETTING_ALLOW
+  }, {
     prefs::kManagedCookiesAllowedForUrls,
     CONTENT_SETTINGS_TYPE_COOKIES,
     CONTENT_SETTING_ALLOW
   }, {
     prefs::kManagedCookiesSessionOnlyForUrls,
     CONTENT_SETTINGS_TYPE_COOKIES,
     CONTENT_SETTING_SESSION_ONLY
   }, {
     prefs::kManagedCookiesBlockedForUrls,
     CONTENT_SETTINGS_TYPE_COOKIES,
@@ skipping 52 matching lines @@
   // in parallel to the preference default-content-settings.  If a
   // default-content-settings-type is managed any user defined excpetions
   // (patterns) for this type are ignored.
   pref_change_registrar_.Add(prefs::kManagedDefaultCookiesSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultImagesSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultJavaScriptSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultPluginsSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultPopupsSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultGeolocationSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultNotificationsSetting, this);
+  pref_change_registrar_.Add(
+      prefs::kManagedDefaultAutoSelectCertificateSetting, this);
 }
 
 PolicyDefaultProvider::~PolicyDefaultProvider() {
   DCHECK(!prefs_);
 }
 
 ContentSetting PolicyDefaultProvider::ProvideDefaultSetting(
     ContentSettingsType content_type) const {
   base::AutoLock auto_lock(lock_);
   return managed_default_content_settings_.settings[content_type];
@@ skipping 30 matching lines @@
     } else if (*name == prefs::kManagedDefaultJavaScriptSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
     } else if (*name == prefs::kManagedDefaultPluginsSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_PLUGINS);
     } else if (*name == prefs::kManagedDefaultPopupsSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_POPUPS);
     } else if (*name == prefs::kManagedDefaultGeolocationSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION);
     } else if (*name == prefs::kManagedDefaultNotificationsSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+    } else if (*name == prefs::kManagedDefaultAutoSelectCertificateSetting) {
+      UpdateManagedDefaultSetting(
+          CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     NotifyObservers(ContentSettingsPattern(),
                     ContentSettingsPattern(),
                     CONTENT_SETTINGS_TYPE_DEFAULT,
                     std::string());
   } else {
@@ skipping 51 matching lines @@
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kManagedDefaultPopupsSetting,
                              CONTENT_SETTING_DEFAULT,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kManagedDefaultGeolocationSetting,
                              CONTENT_SETTING_DEFAULT,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kManagedDefaultNotificationsSetting,
                              CONTENT_SETTING_DEFAULT,
                              PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kManagedDefaultAutoSelectCertificateSetting,
+                             CONTENT_SETTING_ASK,
+                             PrefService::UNSYNCABLE_PREF);
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // PolicyProvider
 
 // static
 void PolicyProvider::RegisterUserPrefs(PrefService* prefs) {
+  prefs->RegisterListPref(prefs::kManagedAutoSelectCertificateForUrls,
+                          PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedCookiesAllowedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedCookiesBlockedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedCookiesSessionOnlyForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedImagesAllowedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedImagesBlockedForUrls,
                           PrefService::UNSYNCABLE_PREF);
@@ skipping 11 matching lines @@
                           PrefService::UNSYNCABLE_PREF);
 }
 
 PolicyProvider::PolicyProvider(PrefService* prefs,
                                DefaultProviderInterface* default_provider)
     : prefs_(prefs),
       default_provider_(default_provider) {
   ReadManagedContentSettings(false);
 
   pref_change_registrar_.Init(prefs_);
+  pref_change_registrar_.Add(prefs::kManagedAutoSelectCertificateForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedCookiesBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedCookiesAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedCookiesSessionOnlyForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedImagesBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedImagesAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPluginsBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPluginsAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPopupsBlockedForUrls, this);
@@ skipping 31 matching lines @@
       // Ignore invalid patterns.
       if (!pattern_pair.first.IsValid()) {
         VLOG(1) << "Ignoring invalid content settings pattern: " <<
                    original_pattern_str;
         continue;
       }
 
       ContentSettingsType content_type =
           kPrefsForManagedContentSettingsMap[i].content_type;
       // If only one pattern was defined auto expand it to a pattern pair.
+      ContentSettingsPattern secondary_pattern =
+          !pattern_pair.second.IsValid() ? ContentSettingsPattern::Wildcard()
+                                         : pattern_pair.second;
       rules->push_back(MakeTuple(
           pattern_pair.first,
-          !pattern_pair.second.IsValid() ? ContentSettingsPattern::Wildcard()
-                                         : pattern_pair.second,
+          secondary_pattern,
           content_type,
           ResourceIdentifier(NO_RESOURCE_IDENTIFIER),
           kPrefsForManagedContentSettingsMap[i].setting));
     }
   }
 }
 
 void PolicyProvider::ReadManagedContentSettings(bool overwrite) {
   ContentSettingsRules rules;
   GetContentSettingsFromPreferences(&rules);
@@ skipping 82 matching lines @@
 }
 
 void PolicyProvider::Observe(int type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     DCHECK_EQ(prefs_, Source<PrefService>(source).ptr());
     std::string* name = Details<std::string>(details).ptr();
-    if (*name == prefs::kManagedCookiesAllowedForUrls ||
+    if (*name == prefs::kManagedAutoSelectCertificateForUrls ||
+        *name == prefs::kManagedCookiesAllowedForUrls ||
         *name == prefs::kManagedCookiesBlockedForUrls ||
         *name == prefs::kManagedCookiesSessionOnlyForUrls ||
         *name == prefs::kManagedImagesAllowedForUrls ||
         *name == prefs::kManagedImagesBlockedForUrls ||
         *name == prefs::kManagedJavaScriptAllowedForUrls ||
         *name == prefs::kManagedJavaScriptBlockedForUrls ||
         *name == prefs::kManagedPluginsAllowedForUrls ||
         *name == prefs::kManagedPluginsBlockedForUrls ||
         *name == prefs::kManagedPopupsAllowedForUrls ||
         *name == prefs::kManagedPopupsBlockedForUrls) {
       ReadManagedContentSettings(true);
       NotifyObservers(ContentSettingsPattern(),
                       ContentSettingsPattern(),
                       CONTENT_SETTINGS_TYPE_DEFAULT,
                       std::string());
     }
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 }  // namespace content_settings