Delegating the "are images allowed" decision to renderer.

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 <algorithm>
 #include <list>
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.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"
@@ skipping 360 matching lines @@
     // TODO(markusheintz): Only the rules that are applied should be added.
     for (std::map<StringPair, PatternSettingSourceTuple>::iterator i(
              settings_map.begin());
          i != settings_map.end();
          ++i) {
       settings->push_back(i->second);
     }
   }
 }
 
+void HostContentSettingsMap::GetConcatenatedSettingsForOneType(
+    ContentSettingsType content_type,
+    const std::string& resource_identifier,
+    ContentSettingRules* rules) const {
+  DCHECK_NE(content_settings::RequiresResourceIdentifier(content_type),
+            resource_identifier.empty());
+  DCHECK(rules);
+
+  rules->clear();
+  for (size_t i = 0; i < content_settings_providers_.size(); ++i) {
+    // Get rules from the content settings provider.
+    Rules rules_for_provider;
+    content_settings_providers_[i]->GetAllContentSettingsRules(
+        content_type, resource_identifier, &rules_for_provider);
+
+    // The rules are returned in arbitrary order. Sort them according to the
+    // ContentSettingPattern precedence relation.

[Bernhard Bauer, 2011/09/13 17:38:11]

Uhhh… is this going to work? The precedence relation wasn't defined to be a
total relation, so there might be some strangeness if we start to sort things by
it.

[marja, 2011/09/15 12:02:00]

Hmm, what would go wrong? Sorting should be ok even if both a < b and b < a
return false, then a and b would just be considered equal and appear in the
result next to each other in arbitrary order. It seems that "a < b == b < a ==
false" occurs when a and b are ContentSettingsPatterns that are in the
"identity" relation with each other, but not when a is a subcase of b, or when
they are unrelated, or when they overlap. "a < b == b > a == true" could result
in some weirdness, but afaics it doesn't happen.

[Bernhard Bauer, 2011/09/15 12:52:19]

Hm, I guess the most important property is transitivity, and we should have
that.

This method is still very similar to GetSettingsForOneType. We should look into
unifying them (and the types used! Or can you tell me the difference between
content_settings::ProviderInterface::Rules, ContentSettingRules and
SettingsForOneType from the top of your head?)

[marja, 2011/09/15 16:00:03]

markusheintz had some diabolic-soul-merchandise going on, and first I didn't
want to meddle in. But I meddled in after all, so now there is only
ContentSettingsForOneType and it's defined in chrome/common/content_settings.h.
I also removed this function and added a sort function as a parameter to
GetSettingsForOneType.

+    std::sort(rules_for_provider.begin(), rules_for_provider.end());
+
+    for (Rules::const_iterator i = rules_for_provider.begin();
+         i != rules_for_provider.end(); ++i) {
+      rules->push_back(ContentSettingPatternTuple(i->primary_pattern,
+                                                  i->secondary_pattern,
+                                                  i->content_setting));
+    }
+  }
+  rules->push_back(ContentSettingPatternTuple(
+      ContentSettingsPattern::Wildcard(),
+      ContentSettingsPattern::Wildcard(),
+      GetDefaultContentSetting(content_type)));
+}
+
 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);
   }
@@ skipping 194 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);
     }
   }
 }