Add content_settings::PolicyProvider and a set of new policies to managed content settings.

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 "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 82 matching lines @@
   }
   is_block_third_party_cookies_managed_ =
       prefs->IsManagedPreference(prefs::kBlockThirdPartyCookies);
   block_nonsandboxed_plugins_ =
       prefs->GetBoolean(prefs::kBlockNonsandboxedPlugins);
 
   // User defined non default content settings are provided by the PrefProvider.
   // The order in which the content settings providers are created is critical,
   // as providers that are further up in the list (i.e. added earlier) override
   // providers further down.
-  content_settings_providers_.push_back(ProviderPtr(
-      new content_settings::PrefProvider(profile)));
+  content_settings_providers_.push_back(
+      make_linked_ptr(new content_settings::PolicyProvider(profile)));
+  content_settings_providers_.push_back(
+      make_linked_ptr(new content_settings::PrefProvider(profile)));
 
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kBlockThirdPartyCookies, this);
   pref_change_registrar_.Add(prefs::kBlockNonsandboxedPlugins, this);
   notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
                               Source<Profile>(profile_));
 }
 
 // static
 void HostContentSettingsMap::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kBlockThirdPartyCookies, false);
   prefs->RegisterBooleanPref(prefs::kBlockNonsandboxedPlugins, false);
   prefs->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, 0);
 
   // Obsolete prefs, for migration:
   prefs->RegisterIntegerPref(prefs::kCookieBehavior,
                              net::StaticCookiePolicy::ALLOW_ALL_COOKIES);
 
   // 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 {
   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;
 }
 
 ContentSetting HostContentSettingsMap::GetContentSetting(
     const GURL& url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) const {
   ContentSetting setting = GetNonDefaultContentSetting(url,
                                                        content_type,
                                                        resource_identifier);
-  if (setting == CONTENT_SETTING_DEFAULT ||
-      IsDefaultContentSettingManaged(content_type)) {
+  if (setting == CONTENT_SETTING_DEFAULT)
     return GetDefaultContentSetting(content_type);
-  }
   return setting;
 }
 
 ContentSetting HostContentSettingsMap::GetNonDefaultContentSetting(
     const GURL& url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) const {
   if (ShouldAllowAllContent(url))
     return CONTENT_SETTING_ALLOW;
 
   // Iterate through the list of providers and break when the first non default
   // setting is found.
   ContentSetting provided_setting(CONTENT_SETTING_DEFAULT);
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     provided_setting = (*provider)->GetContentSetting(
         url, url, content_type, resource_identifier);
-    if (provided_setting != CONTENT_SETTING_DEFAULT)
-      break;
+    bool isManaged = (*provider)->ContentSettingsTypeIsManaged(content_type);
+    if (provided_setting != CONTENT_SETTING_DEFAULT || isManaged)
+      return provided_setting;
   }
   return provided_setting;
 }
 
 ContentSettings HostContentSettingsMap::GetContentSettings(
     const GURL& url) const {
   ContentSettings output = GetNonDefaultContentSettings(url);
 
   // If we require a resource identifier, set the content settings to default,
   // otherwise make the defaults explicit.
   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) ||
-         IsDefaultContentSettingManaged(ContentSettingsType(j))) {
+    if (output.settings[j] == CONTENT_SETTING_DEFAULT &&
+        j != CONTENT_SETTINGS_TYPE_PLUGINS) {
       output.settings[j] = GetDefaultContentSetting(ContentSettingsType(j));
     }
   }
   return output;
 }
 
 ContentSettings HostContentSettingsMap::GetNonDefaultContentSettings(
     const GURL& url) const {
   if (ShouldAllowAllContent(url))
       return ContentSettings(CONTENT_SETTING_ALLOW);
@@ skipping 14 matching lines @@
   settings->clear();
 
   // Collect content_settings::Rules for the given content_type and
   // resource_identifier from the content settings providers.
   Rules content_settings_rules;
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     // TODO(markusheintz): Only the rules that are applied should be collected.
     // Merge rules.
+    // TODO(markusheintz): GetAllContentSettingsRules should maybe not clear the
+    // passed vector in case rule sets are just unified.
+    Rules rules;
     (*provider)->GetAllContentSettingsRules(
-      content_type, resource_identifier, &content_settings_rules);
+        content_type, resource_identifier, &rules);
+    content_settings_rules.insert(content_settings_rules.end(),
+                                  rules.begin(),
+                                  rules.end());
   }
 
   // convert Rules to SettingsForOneType
   for (const_rules_iterator rule_iterator =
            content_settings_rules.begin();
        rule_iterator != content_settings_rules.end();
        ++rule_iterator) {
     settings->push_back(std::make_pair(ContentSettingsPattern(
         rule_iterator->requesting_url_pattern),
         rule_iterator->content_setting));
@@ skipping 224 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);
     }
   }
 }