Cleanup content settings code

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 <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/content_settings_default_provider.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_extension_provider.h"
 #include "chrome/browser/content_settings/content_settings_observable_provider.h"
 #include "chrome/browser/content_settings/content_settings_policy_provider.h"
 #include "chrome/browser/content_settings/content_settings_pref_provider.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/content_settings_rule.h"
-#include "chrome/browser/content_settings/content_settings_utils.h"

[marja, 2011/12/06 09:47:12]

I don't think you should remove this include, this file uses
content_settings::GetContentSettingValueAndPatterns.

[markusheintz_, 2011/12/06 16:29:59]

Done.

 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/user_metrics.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 28 matching lines @@
                    HostContentSettingsMap::NUM_PROVIDER_TYPES,
                kProviderSourceMap_has_incorrect_size);
 
 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;
 }
 
-ContentSetting GetDefaultSetting(
-    content_settings::RuleIterator* rule_iterator) {
-  ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
-  while (rule_iterator->HasNext()) {
-    content_settings::Rule rule = rule_iterator->Next();
-    if (rule.primary_pattern == wildcard &&
-        rule.secondary_pattern == wildcard) {
-      return content_settings::ValueToContentSetting(rule.value.get());
-    }
-  }
-  return CONTENT_SETTING_DEFAULT;
+// Returns true if the |content_type| supports a resource identifier.
+// Resource identifiers are supported (but not required) for plug-ins.
+bool SupportsResourceIdentifier(ContentSettingsType content_type) {
+  return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
 }
 
 }  // namespace
 
 HostContentSettingsMap::HostContentSettingsMap(
     PrefService* prefs,
     ExtensionService* extension_service,
     bool incognito)
     : prefs_(prefs),
       is_off_the_record_(incognito) {
@@ skipping 33 matching lines @@
   content_settings::DefaultProvider::RegisterUserPrefs(prefs);
   content_settings::PrefProvider::RegisterUserPrefs(prefs);
   content_settings::PolicyProvider::RegisterUserPrefs(prefs);
 }
 
 ContentSetting HostContentSettingsMap::GetDefaultContentSettingFromProvider(
     ContentSettingsType content_type,
     content_settings::ProviderInterface* provider) const {
   scoped_ptr<content_settings::RuleIterator> rule_iterator(
       provider->GetRuleIterator(content_type, "", false));
-  return GetDefaultSetting(rule_iterator.get());
+
+  ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
+  while (rule_iterator->HasNext()) {
+    content_settings::Rule rule = rule_iterator->Next();
+    if (rule.primary_pattern == wildcard &&
+        rule.secondary_pattern == wildcard) {
+      return content_settings::ValueToContentSetting(rule.value.get());
+    }
+  }
+  return CONTENT_SETTING_DEFAULT;
 }
 
 ContentSetting HostContentSettingsMap::GetDefaultContentSetting(
     ContentSettingsType content_type,
     std::string* provider_id) const {
   DCHECK(!ContentTypeHasCompoundValue(content_type));
 
   // Iterate through the list of providers and return the first non-NULL value
   // that matches |primary_url| and |secondary_url|.
   for (ConstProviderIterator provider = content_settings_providers_.begin();
@@ skipping 15 matching lines @@
   // DefaultProvider to always provide a value.
   NOTREACHED();
   return CONTENT_SETTING_DEFAULT;
 }
 
 ContentSetting HostContentSettingsMap::GetContentSetting(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) const {
+  DCHECK(!ContentTypeHasCompoundValue(content_type));
   scoped_ptr<base::Value> value(GetWebsiteSetting(
       primary_url, secondary_url, content_type, resource_identifier, NULL));
   return content_settings::ValueToContentSetting(value.get());
 }
 
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSettingsForOneType* settings) const {
-  DCHECK(content_settings::SupportsResourceIdentifier(content_type) ||
+  DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
   DCHECK(settings);
 
   settings->clear();
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     // For each provider, iterate first the incognito-specific rules, then the
     // normal rules.
     if (is_off_the_record_) {
       AddSettingsForOneType(provider->second,
                             provider->first,
                             content_type,
                             resource_identifier,
                             settings,
                             true);
     }
     AddSettingsForOneType(provider->second,
                           provider->first,
                           content_type,
                           resource_identifier,
                           settings,
                           false);
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
-  DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE);
+  DCHECK(!ContentTypeHasCompoundValue(content_type));
   DCHECK(IsSettingAllowedForType(setting, content_type));
 
   base::Value* value = NULL;
   if (setting != CONTENT_SETTING_DEFAULT)
     value = Value::CreateIntegerValue(setting);
   SetWebsiteSetting(
       ContentSettingsPattern::Wildcard(),
       ContentSettingsPattern::Wildcard(),
       content_type,
       std::string(),
       value);
 }
 
 void HostContentSettingsMap::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     base::Value* value) {
   DCHECK(IsValueAllowedForType(value, content_type));
-  DCHECK(content_settings::SupportsResourceIdentifier(content_type) ||
+  DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
   for (ProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     if (provider->second->SetWebsiteSetting(primary_pattern,
                                             secondary_pattern,
                                             content_type,
                                             resource_identifier,
                                             value)) {
       return;
     }
   }
   NOTREACHED();
 }
 
 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(!ContentTypeHasCompoundValue(content_type));
   base::Value* value = NULL;
   if (setting != CONTENT_SETTING_DEFAULT)
     value = Value::CreateIntegerValue(setting);
   SetWebsiteSetting(primary_pattern,
                     secondary_pattern,
                     content_type,
                     resource_identifier,
                     value);
 }
 
 void HostContentSettingsMap::AddExceptionForURL(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSetting setting) {
   // TODO(markusheintz): Until the UI supports pattern pairs, both urls must
   // match.
   DCHECK(primary_url == secondary_url);
+  DCHECK(!ContentTypeHasCompoundValue(content_type));
 
   // Make sure there is no entry that would override the pattern we are about
   // to insert for exactly this URL.
   SetContentSetting(ContentSettingsPattern::FromURLNoWildcard(primary_url),
                     ContentSettingsPattern::Wildcard(),
                     content_type,
                     resource_identifier,
                     CONTENT_SETTING_DEFAULT);
 
   SetContentSetting(ContentSettingsPattern::FromURL(primary_url),
@@ skipping 125 matching lines @@
          primary_url.SchemeIs(chrome::kChromeInternalScheme) ||
          primary_url.SchemeIs(chrome::kChromeUIScheme);
 }
 
 base::Value* HostContentSettingsMap::GetWebsiteSetting(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     content_settings::SettingInfo* info) const {
-  DCHECK(content_settings::SupportsResourceIdentifier(content_type) ||
+  DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
 
   // Check if the scheme of the requesting url is whitelisted.
   if (ShouldAllowAllContent(primary_url, secondary_url, content_type)) {
     if (info) {
       info->source = content_settings::SETTING_SOURCE_WHITELIST;
       info->primary_pattern = ContentSettingsPattern::Wildcard();
       info->secondary_pattern = ContentSettingsPattern::Wildcard();
     }
     return Value::CreateIntegerValue(CONTENT_SETTING_ALLOW);
   }
 
   ContentSettingsPattern* primary_pattern = NULL;
   ContentSettingsPattern* secondary_pattern = NULL;
   if (info) {
     primary_pattern = &info->primary_pattern;
     secondary_pattern = &info->secondary_pattern;
   }
 
   // The list of |content_settings_providers_| is ordered according to their
   // precedence.
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     base::Value* value = content_settings::GetContentSettingValueAndPatterns(

[marja, 2011/12/06 09:47:12]

(Here.)

[markusheintz_, 2011/12/06 16:29:59]

Done.

         provider->second, primary_url, secondary_url, content_type,
         resource_identifier, is_off_the_record_,
         primary_pattern, secondary_pattern);
     if (value) {
       if (info)
         info->source = kProviderSourceMap[provider->first];
       return value;
     }
   }
 
   if (info) {
     info->source = content_settings::SETTING_SOURCE_NONE;
     info->primary_pattern = ContentSettingsPattern();
     info->secondary_pattern = ContentSettingsPattern();
   }
   return NULL;
 }