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/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_view.h"
@@ skipping 57 matching lines @@
 void ContentSettingsObserver::SetContentSettings(
     const ContentSettings& settings) {
   current_content_settings_ = settings;
 }
 
 void ContentSettingsObserver::SetDefaultContentSettings(
     const ContentSettings& settings) {
   default_settings_ = settings;
 }
 
+void ContentSettingsObserver::SetImageSettingRules(
+    const ContentSettingsForOneType* image_setting_rules) {
+  image_setting_rules_ = image_setting_rules;
+}
+
 ContentSetting ContentSettingsObserver::GetContentSetting(
     ContentSettingsType type) {
   // Don't call this for plug-ins.
   DCHECK_NE(CONTENT_SETTINGS_TYPE_PLUGINS, type);
   return current_content_settings_.settings[type];
 }
 
 void ContentSettingsObserver::DidBlockContentType(
     ContentSettingsType settings_type,
     const std::string& resource_identifier) {
@@ skipping 23 matching lines @@
 }
 
 void ContentSettingsObserver::DidCommitProvisionalLoad(
     WebFrame* frame, bool is_new_navigation) {
   if (frame->parent())
     return; // Not a top-level navigation.
 
   NavigationState* state = NavigationState::FromDataSource(frame->dataSource());
   if (!state->was_within_same_page()) {
     // Clear "block" flags for the new page. This needs to happen before any of
-    // allowScripts(), allowImages(), allowPlugins() is called for the new page
+    // allowScripts(), allowImage(), allowPlugins() is called for the new page
     // so that these functions can correctly detect that a piece of content
     // flipped from "not blocked" to "blocked".
     ClearBlockedContentSettings();
     plugins_temporarily_allowed_ = false;
   }
 
   GURL url = frame->document().url();
 
   if (frame->document().securityOrigin().toString() == "null" &&
       !url.SchemeIs(chrome::kFileScheme)) {
@@ skipping 59 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::AllowImage(WebFrame* frame,
                                          bool enabled_per_settings,
                                          const WebURL& image_url) {
-  if (enabled_per_settings &&
-      AllowContentType(CONTENT_SETTINGS_TYPE_IMAGES)) {
-    return true;
-  }
-
   if (IsWhitelistedForContentSettings(frame))
     return true;
 
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES, std::string());
-  return false;  // Other protocols fall through here.
+  bool allow = enabled_per_settings;
+
+  WebString top_origin = frame->top()->document().securityOrigin().toString();
+  GURL page_url(frame->document().url());
+  GURL primary_url;
+  // For file:// URLs, the top_origin is unique ("null"). Use the file:// URL as
+  // the primary URL.
+  if (top_origin == "null" && page_url.SchemeIsFile())

[Bernhard Bauer, 2011/10/21 10:10:10]

Are there other cases where we might want to use the URL instead? 
http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/third_party/WebKit/So...
says that the SecurityOrigin could be unique for sandboxed iframes as well.

Also, we might want to pull this out into a general method (for example, to use
it for plug-in content settings as well).

[marja, 2011/10/21 10:25:05]

How about this version: use the doc url always when the top origin url is
unique? (I'd like to leave out from this CL the other Allow* funcs using this
func.) Still lgty?

[Bernhard Bauer, 2011/10/21 10:57:35]

I guess both versions serve the file URL use case, which is what I was concerned
about, so LGTM. I don't know enough about all the other edge cases to judge how
we want to treat them.

+    primary_url = page_url;
+  else
+    primary_url = GURL(top_origin);
+
+  GURL secondary_url(image_url);
+  if (image_setting_rules_ &&
+      enabled_per_settings) {
+    ContentSettingsForOneType::const_iterator it;
+    for (it = image_setting_rules_->begin();
+         it != image_setting_rules_->end(); ++it) {
+      if (it->primary_pattern.Matches(primary_url) &&
+          it->secondary_pattern.Matches(secondary_url)) {
+        allow = (it->setting != CONTENT_SETTING_BLOCK);
+        break;
+      }
+    }
+  }
+
+  if (!allow)
+    DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES, std::string());
+  return allow;
 }
 
 bool ContentSettingsObserver::AllowIndexedDB(WebFrame* frame,
                                              const WebString& name,
                                              const WebSecurityOrigin& origin) {
   if (frame->document().securityOrigin().isEmpty() ||
       frame->top()->document().securityOrigin().isEmpty())
     return false; // Uninitialized document.
 
   bool result = false;
@@ skipping 67 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();
 }