Add a method to the HostContentSettings map to return the |Value| of a content setting

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"
+#include "base/json/json_reader.h"
 #include "chrome/browser/content_settings/content_settings_pattern.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 
 namespace {
 
 // 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,
+  NULL,

[wtc, 2011/09/02 18:53:22]

Just wanted to make sure you do want a NULL entry here,
rather than removing the entry altogether.

[markusheintz_, 2011/09/02 19:39:12]

Yes I really want a NULL entry here bc the size has to match
CONTENT_SETTINGS_NUM_TYPES.

 };
 
 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,
@@ skipping 71 matching lines @@
       PatternPair pattern_pair = ParsePatternString(original_pattern_str);
       // 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;
+      DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
       // 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,
           secondary_pattern,
           content_type,
           ResourceIdentifier(NO_RESOURCE_IDENTIFIER),
           kPrefsForManagedContentSettingsMap[i].setting));
     }
   }
 }
 
+void PolicyProvider::GetAutoSelectCertificateSettingsFromPreferences(
+    OriginIdentifierValueMap* value_map) {
+  const char* pref_name = prefs::kManagedAutoSelectCertificateForUrls;
+
+  if (!prefs_->HasPrefPath(pref_name)) {
+    VLOG(2) << "Skipping unset preference: " << pref_name;
+    return;
+  }
+
+  const PrefService::Preference* pref = prefs_->FindPreference(pref_name);
+  DCHECK(pref);
+  DCHECK(pref->IsManaged());
+
+  const ListValue* pattern_filter_str_list = NULL;
+  if (!pref->GetValue()->GetAsList(&pattern_filter_str_list)) {
+    NOTREACHED();
+    return;
+  }
+
+  // Parse the list of pattern filter strings. A pattern filter string has the
+  // following format:
+  //
+  // PATTERN_FILTER_STRING ::= CONTENT_SETTINGS_PATTERN_STRING '|' FILTER_STRING
+  // FILTER_STRING ::= JSON_STRING
+  //
+  // e.g. "[*.]example.com|{\"ISSUER\":{\"CN\":\"some name\"}}"

[Mattias Nissler (ping if slow), 2011/09/02 15:06:21]

can we maybe just make the pattern also part of the JSON? i.e. adding a
'pattern' key and moving the selectors to a 'selectors' subdict?

[markusheintz_, 2011/09/02 19:39:12]

Done.

+  // '"' characters are escaped with a '\' in this example so the '\' characters
+  // are not part of the string.
+  //
+  // As the pipe symbol can not occure in a content settings pattern string it
+  // is used to separate the content settings pattern string from the JSON
+  // string.
+  for (size_t j = 0; j < pattern_filter_str_list->GetSize(); ++j) {
+    std::string pattern_filter_str;
+    pattern_filter_str_list->GetString(j, &pattern_filter_str);
+
+    size_t separator_pos = pattern_filter_str.find('|');
+    if (separator_pos == std::string::npos) {
+      VLOG(1) << "No filter string found. Ignoring list entry: "
+              << pattern_filter_str;
+      continue;
+    }
+    std::string pattern_str = pattern_filter_str.substr(0, separator_pos);
+    std::string filter_str = pattern_filter_str.substr(separator_pos + 1);
+
+    ContentSettingsPattern pattern =
+        ContentSettingsPattern::FromString(pattern_str);
+    // Ignore invalid patterns.
+    if (!pattern.IsValid()) {
+      VLOG(1) << "Invalid content settings pattern: " << pattern_str
+              << ". Ignoring list entry: " << pattern_filter_str;
+      continue;
+    }
+
+    // Allow trailing commas to be more fault tolerant.
+    scoped_ptr<Value> filter_value(base::JSONReader::Read(filter_str, true));
+    if (!filter_value.get()) {
+      VLOG(1) << "Invalid JSON string: " << filter_str
+              << ". Ignoring list entry: " << pattern_filter_str;
+      continue;
+    }
+    DCHECK(filter_value->IsType(Value::TYPE_DICTIONARY));
+    value_map->SetValue(pattern,
+                        ContentSettingsPattern::Wildcard(),
+                        CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
+                        std::string(),
+                        filter_value.release());
+  }
+}
+
 void PolicyProvider::ReadManagedContentSettings(bool overwrite) {
   ContentSettingsRules rules;
   GetContentSettingsFromPreferences(&rules);
   {
     base::AutoLock auto_lock(lock_);
     if (overwrite)
       value_map_.clear();
     for (ContentSettingsRules::iterator rule = rules.begin();
          rule != rules.end();
          ++rule) {
       value_map_.SetValue(rule->a,
                           rule->b,
                           rule->c,
                           rule->d,
                           Value::CreateIntegerValue(rule->e));
     }
+    GetAutoSelectCertificateSettingsFromPreferences(&value_map_);
   }
 }
 
 // Since the PolicyProvider is a read only content settings provider, all
 // methodes of the ProviderInterface that set or delete any settings do nothing.
 void PolicyProvider::SetContentSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     ContentSetting content_setting) {
 }
 
 ContentSetting PolicyProvider::GetContentSetting(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier) const {
+  DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
   // Resource identifier are not supported by policies as long as the feature is
   // behind a flag. So resource identifiers are simply ignored.
   scoped_ptr<Value> value(GetContentSettingValue(primary_url,
                                                  secondary_url,
                                                  content_type,
                                                  resource_identifier));
   ContentSetting setting =
       value.get() ? ValueToContentSetting(value.get())
                   : CONTENT_SETTING_DEFAULT;
   if (setting == CONTENT_SETTING_DEFAULT && default_provider_)
@@ skipping 82 matching lines @@
                       ContentSettingsPattern(),
                       CONTENT_SETTINGS_TYPE_DEFAULT,
                       std::string());
     }
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 }  // namespace content_settings