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

chrome/browser/content_settings/host_content_settings_map.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/host_content_settings_map.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/string_util.h"
@@ skipping 52 matching lines @@
 typedef content_settings::ProviderInterface::Rules Rules;
 
 typedef std::pair<std::string, std::string> StringPair;
 
 const char* kProviderNames[] = {
   "policy",
   "extension",
   "preference"
 };
 
+bool ContentTypeHasCompoundValue(ContentSettingsType type) {
+  // Values for content type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE are
+  // of type dictionary/map. Compound types like dictionaries can't be mapped to
+  // the type |ContentSetting|.
+  return type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE;
+}
+
 }  // namespace
 
 HostContentSettingsMap::HostContentSettingsMap(
     PrefService* prefs,
     ExtensionService* extension_service,
     bool incognito)
     : prefs_(prefs),
       is_off_the_record_(incognito),
       updating_preferences_(false),
       block_third_party_cookies_(false),
@@ skipping 71 matching lines @@
 
   // Register the prefs for the content settings providers.
   content_settings::PrefDefaultProvider::RegisterUserPrefs(prefs);
   content_settings::PolicyDefaultProvider::RegisterUserPrefs(prefs);
   content_settings::PrefProvider::RegisterUserPrefs(prefs);
   content_settings::PolicyProvider::RegisterUserPrefs(prefs);
 }
 
 ContentSetting HostContentSettingsMap::GetDefaultContentSetting(
     ContentSettingsType content_type) const {
+  DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
   ContentSetting setting = CONTENT_SETTING_DEFAULT;
   for (ConstDefaultProviderIterator provider =
            default_content_settings_providers_.begin();
        provider != default_content_settings_providers_.end(); ++provider) {
     ContentSetting provided_setting =
         (*provider)->ProvideDefaultSetting(content_type);
     if (provided_setting != CONTENT_SETTING_DEFAULT)
       setting = provided_setting;
   }
   // The method GetDefaultContentSetting always has to return an explicit
   // value that is to be used as default. We here rely on the
   // PrefContentSettingProvider to always provide a value.
   CHECK_NE(CONTENT_SETTING_DEFAULT, setting);
   return setting;
 }
 
 ContentSettings HostContentSettingsMap::GetDefaultContentSettings() const {
   ContentSettings output(CONTENT_SETTING_DEFAULT);
-  for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i)
-    output.settings[i] = GetDefaultContentSetting(ContentSettingsType(i));
+  for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
+    if (!ContentTypeHasCompoundValue(ContentSettingsType(i)))
+        output.settings[i] = GetDefaultContentSetting(ContentSettingsType(i));

[wtc, 2011/09/06 22:11:42]

Indent by two spaces.

[markusheintz_, 2011/09/07 19:29:48]

Done.

+  }
   return output;
 }
 
 ContentSetting HostContentSettingsMap::GetCookieContentSetting(
     const GURL& url,
     const GURL& first_party_url,
     bool setting_cookie) const {
   if (ShouldAllowAllContent(first_party_url, CONTENT_SETTINGS_TYPE_COOKIES))
     return CONTENT_SETTING_ALLOW;
 
@@ skipping 31 matching lines @@
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) const {
   DCHECK_NE(CONTENT_SETTINGS_TYPE_COOKIES, content_type);
   DCHECK_NE(content_settings::RequiresResourceIdentifier(content_type),
             resource_identifier.empty());
   return GetContentSettingInternal(
       primary_url, secondary_url, content_type, resource_identifier);
 }
 
+Value* HostContentSettingsMap::GetContentSettingValue(
+    const GURL& primary_url,
+    const GURL& secondary_url,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier) const {
+  // Check if the scheme of the requesting url is whitelisted.
+  if (ShouldAllowAllContent(secondary_url, content_type))
+    return Value::CreateIntegerValue(CONTENT_SETTING_ALLOW);
+
+  // First check if there are specific settings for the |primary_url| and
+  // |secondary_url|. The list of |content_settings_providers_| is ordered
+  // according to their priority.
+  for (ConstProviderIterator provider = content_settings_providers_.begin();
+       provider != content_settings_providers_.end();
+       ++provider) {
+    Value* value = (*provider)->GetContentSettingValue(
+        primary_url, secondary_url, content_type, resource_identifier);
+    if (value)
+      return value;
+  }
+
+  // If no specific settings were found for the |primary_url|, |secondary_url|
+  // pair, then the default value for the given |content_type| should be
+  // returned. For CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE the default is
+  // 'no filter available'. That's why we return |NULL| for this content type.
+  if (content_type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE)
+    return NULL;
+  return Value::CreateIntegerValue(GetDefaultContentSetting(content_type));
+}
+
 ContentSetting HostContentSettingsMap::GetContentSettingInternal(
       const GURL& primary_url,
       const GURL& secondary_url,
       ContentSettingsType content_type,
       const std::string& resource_identifier) const {
   ContentSetting setting = GetNonDefaultContentSetting(
       primary_url, secondary_url, content_type, resource_identifier);
   if (setting == CONTENT_SETTING_DEFAULT)
     return GetDefaultContentSetting(content_type);
   return setting;
@@ skipping 21 matching lines @@
   return provided_setting;
 }
 
 ContentSettings HostContentSettingsMap::GetContentSettings(
       const GURL& primary_url,
       const GURL& secondary_url) const {
   ContentSettings output = GetNonDefaultContentSettings(
       primary_url, secondary_url);
 
   // If we require a resource identifier, set the content settings to default,
-  // otherwise make the defaults explicit.
+  // otherwise make the defaults explicit. Values for content type
+  // CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE can't be mapped to the type
+  // |ContentSetting|. So we ignore them here.
   for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
     // A managed default content setting has the highest priority and hence
     // will overwrite any previously set value.
     if (output.settings[j] == CONTENT_SETTING_DEFAULT &&
-        j != CONTENT_SETTINGS_TYPE_PLUGINS) {
+        j != CONTENT_SETTINGS_TYPE_PLUGINS &&
+        !ContentTypeHasCompoundValue(ContentSettingsType(j))) {
       output.settings[j] = GetDefaultContentSetting(ContentSettingsType(j));
     }
   }
   return output;
 }
 
 ContentSettings HostContentSettingsMap::GetNonDefaultContentSettings(
     const GURL& primary_url,
     const GURL& secondary_url) const {
   ContentSettings output(CONTENT_SETTING_DEFAULT);
   for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
-    output.settings[j] = GetNonDefaultContentSetting(
-        primary_url,
-        secondary_url,
-        ContentSettingsType(j),
-        "");
+    if (!ContentTypeHasCompoundValue(ContentSettingsType(j))) {
+      output.settings[j] = GetNonDefaultContentSetting(
+          primary_url,
+          secondary_url,
+          ContentSettingsType(j),
+          "");
+    }
   }
   return output;
 }
 
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     SettingsForOneType* settings) const {
   DCHECK_NE(content_settings::RequiresResourceIdentifier(content_type),
             resource_identifier.empty());
@@ skipping 27 matching lines @@
          i != settings_map.end();
          ++i) {
       settings->push_back(i->second);
     }
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
+  DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
   DCHECK(IsSettingAllowedForType(setting, content_type));
   for (DefaultProviderIterator provider =
            default_content_settings_providers_.begin();
        provider != default_content_settings_providers_.end(); ++provider) {
     (*provider)->UpdateDefaultSetting(content_type, setting);
   }
 }
 
 void HostContentSettingsMap::SetContentSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSetting setting) {
+  DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
   DCHECK(IsSettingAllowedForType(setting, content_type));
   DCHECK_NE(content_settings::RequiresResourceIdentifier(content_type),
             resource_identifier.empty());
   for (ProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     (*provider)->SetContentSetting(
         primary_pattern,
         secondary_pattern,
         content_type,
@@ skipping 175 matching lines @@
         SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_COOKIES,
             (cookie_behavior == net::StaticCookiePolicy::BLOCK_ALL_COOKIES) ?
                 CONTENT_SETTING_BLOCK : CONTENT_SETTING_ALLOW);
     }
     if (!prefs_->HasPrefPath(prefs::kBlockThirdPartyCookies)) {
       SetBlockThirdPartyCookies(cookie_behavior ==
           net::StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES);
     }
   }
 }