Content settings: allow scripts on interstitial pages.

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/view_messages.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrameClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
@@ skipping 68 matching lines @@
   return CONTENT_SETTING_DEFAULT;
 }
 
 }  // namespace
 
 ContentSettingsObserver::ContentSettingsObserver(
     content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<ContentSettingsObserver>(render_view),
       content_setting_rules_(NULL),
-      plugins_temporarily_allowed_(false) {
+      plugins_temporarily_allowed_(false),
+      is_interstitial_page_(false) {
   ClearBlockedContentSettings();
 }
 
 ContentSettingsObserver::~ContentSettingsObserver() {
 }
 
 void ContentSettingsObserver::SetContentSettingRules(
     const RendererContentSettingRules* content_setting_rules) {
   content_setting_rules_ = content_setting_rules;
 }
@@ skipping 12 matching lines @@
   }
 }
 
 bool ContentSettingsObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     // Don't swallow LoadBlockedPlugins messages, as they're sent to every
     // blocked plugin.
     IPC_MESSAGE_HANDLER_GENERIC(ChromeViewMsg_LoadBlockedPlugins,
                                 OnLoadBlockedPlugins(); handled = false)
+    IPC_MESSAGE_HANDLER(ViewMsg_SetAsInterstitial, OnSetAsInterstitial)

[jochen (gone - plz use gerrit), 2011/12/02 12:38:08]

I think the render view impl should handle the message, and invoke a callback in
render view observer.

The chrome render view observer would implement that callback and forward the
info to the content settings observer. Yay for APIs

[marja, 2011/12/02 14:39:34]

Done.

     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ContentSettingsObserver::DidCommitProvisionalLoad(
     WebFrame* frame, bool is_new_navigation) {
   if (frame->parent())
     return; // Not a top-level navigation.
 
@@ skipping 79 matching lines @@
   return result;
 }
 
 bool ContentSettingsObserver::AllowPlugins(WebFrame* frame,
                                            bool enabled_per_settings) {
   return enabled_per_settings;
 }
 
 bool ContentSettingsObserver::AllowScript(WebFrame* frame,
                                           bool enabled_per_settings) {
+  if (is_interstitial_page_)
+    return true;
   if (!enabled_per_settings)
     return false;
 
   std::map<WebFrame*, bool>::const_iterator it =
       cached_script_permissions_.find(frame);
   if (it != cached_script_permissions_.end())
     return it->second;
 
   // Evaluate the content setting rules before
   // |IsWhitelistedForContentSettings|; if there is only the default rule
   // allowing all scripts, it's quicker this way.
   bool allow = true;
   if (content_setting_rules_) {
     ContentSetting setting = GetContentSettingFromRules(
         content_setting_rules_->script_rules,
         frame,
         GURL(frame->document().securityOrigin().toString()));
     allow = setting != CONTENT_SETTING_BLOCK;
   }
   allow = allow || IsWhitelistedForContentSettings(frame);
 
   cached_script_permissions_[frame] = allow;
   return allow;
 }
 
 bool ContentSettingsObserver::AllowScriptFromSource(
     WebFrame* frame,
     bool enabled_per_settings,
     const WebKit::WebURL& script_url) {
+  if (is_interstitial_page_)
+    return true;
   if (!enabled_per_settings)
     return false;
 
   bool allow = true;
   if (content_setting_rules_) {
     ContentSetting setting = GetContentSettingFromRules(
         content_setting_rules_->script_rules,
         frame,
         GURL(script_url));
     allow = setting != CONTENT_SETTING_BLOCK;
@@ skipping 27 matching lines @@
 }
 
 void ContentSettingsObserver::DidNotAllowScript(WebFrame* frame) {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string());
 }
 
 void ContentSettingsObserver::OnLoadBlockedPlugins() {
   plugins_temporarily_allowed_ = true;
 }
 
+void ContentSettingsObserver::OnSetAsInterstitial() {
+  is_interstitial_page_ = true;
+}
+
 void ContentSettingsObserver::ClearBlockedContentSettings() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i)
     content_blocked_[i] = false;
   cached_storage_permissions_.clear();
   cached_script_permissions_.clear();
 }