Delegating the "are images allowed" decision to renderer.

chrome/renderer/content_settings_observer.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/renderer/content_settings_observer.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/database_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 34 matching lines @@
              document_url.ExtractFileName().empty();
     }
   }
 
   return false;
 }
 
 }  // namespace
 
 ContentSettings ContentSettingsObserver::default_settings_;
+ContentSettingRules ContentSettingsObserver::image_setting_rules_;
 
 ContentSettingsObserver::ContentSettingsObserver(RenderView* render_view)
     : RenderViewObserver(render_view),
       RenderViewObserverTracker<ContentSettingsObserver>(render_view),
       plugins_temporarily_allowed_(false) {
   ClearBlockedContentSettings();
 }
 
 ContentSettingsObserver::~ContentSettingsObserver() {
 }
 
 void ContentSettingsObserver::SetContentSettings(
     const ContentSettings& settings) {
   current_content_settings_ = settings;
 }
 
 void ContentSettingsObserver::SetDefaultContentSettings(
     const ContentSettings& settings) {
   default_settings_ = settings;
 }
 
+// static
+void ContentSettingsObserver::SetImageSettingRules(
+    const ContentSettingRules& rules) {
+  image_setting_rules_ = rules;
+}
+
 ContentSetting ContentSettingsObserver::GetContentSetting(
     ContentSettingsType type) {
   if (type == CONTENT_SETTINGS_TYPE_PLUGINS &&
       plugins_temporarily_allowed_) {
     return CONTENT_SETTING_ALLOW;
   }
   return current_content_settings_.settings[type];
 }
 
 void ContentSettingsObserver::DidBlockContentType(
@@ skipping 103 matching lines @@
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowFileSystem(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()), &result));
   return result;
 }
 
 bool ContentSettingsObserver::AllowImages(WebFrame* frame,
                                           bool enabled_per_settings) {
-  if (enabled_per_settings &&
-      AllowContentType(CONTENT_SETTINGS_TYPE_IMAGES)) {
-    return true;
+  if (frame->document().securityOrigin().isEmpty() ||
+      frame->top()->document().securityOrigin().isEmpty())
+    return false; // Uninitialized document.

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

Does this change the behavior?

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

I moved the IsWhiteListedForContentSettings up, that seemed the right thing to
do at least. What to do with uninitialized documents: 1) return false 2) return
true 3) return the default setting (which is the last element of the image
settings)?

+
+  if (enabled_per_settings) {
+    ContentSettingRules::const_iterator it;
+    for (it = image_setting_rules_.begin();
+         it != image_setting_rules_.end(); ++it) {
+      if (it->a.Matches(GURL(frame->document().securityOrigin().toString())) &&
+          it->b.Matches(
+              GURL(frame->top()->document().securityOrigin().toString()))) {
+        return (it->c != CONTENT_SETTING_BLOCK);

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

This simply returns |false| when the setting is BLOCK, without notifying the
browser about it (which we used to do below with DidBlockContentType).

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

Ahh, true! I added the DidBlockContentType here and in the "return false" case
above.

+      }
+    }
   }
 
   if (IsWhitelistedForContentSettings(frame))
     return true;
 
   DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES, std::string());
   return false;  // Other protocols fall through here.
 }
 
 bool ContentSettingsObserver::AllowIndexedDB(WebFrame* frame,
@@ skipping 74 matching lines @@
   // CONTENT_SETTING_ASK is only valid for cookies.
   return current_content_settings_.settings[settings_type] !=
       CONTENT_SETTING_BLOCK;
 }
 
 void ContentSettingsObserver::ClearBlockedContentSettings() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i)
     content_blocked_[i] = false;
   cached_storage_permissions_.clear();
 }