Move the content settings code out of RenderView, since it belongs in the Chrome layer.

content/renderer/render_view.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 "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 258 matching lines @@
 static const char kBackForwardNavigationScheme[] = "history";
 
 static void GetRedirectChain(WebDataSource* ds, std::vector<GURL>* result) {
   WebVector<WebURL> urls;
   ds->redirectChain(urls);
   result->reserve(urls.size());
   for (size_t i = 0; i < urls.size(); ++i)
     result->push_back(urls[i]);
 }
 
-// True if |frame| contains content that is white-listed for content settings.
-static bool IsWhitelistedForContentSettings(WebFrame* frame) {
-  WebSecurityOrigin origin = frame->securityOrigin();
-  if (origin.isEmpty())
-    return false;  // Uninitialized document?
-
-  if (EqualsASCII(origin.protocol(), chrome::kChromeUIScheme))
-    return true;  // Browser UI elements should still work.
-
-  // If the scheme is ftp: or file:, an empty file name indicates a directory
-  // listing, which requires JavaScript to function properly.
-  GURL frame_url = frame->url();
-  const char* kDirProtocols[] = { "ftp", "file" };
-  for (size_t i = 0; i < arraysize(kDirProtocols); ++i) {
-    if (EqualsASCII(origin.protocol(), kDirProtocols[i])) {
-      return frame_url.SchemeIs(kDirProtocols[i]) &&
-             frame_url.ExtractFileName().empty();
-    }
-  }
-
-  return false;
-}
-
 static bool WebAccessibilityNotificationToViewHostMsg(
     WebAccessibilityNotification notification,
     ViewHostMsg_AccessibilityNotification_Type::Value* type) {
   switch (notification) {
     case WebKit::WebAccessibilityNotificationCheckedStateChanged:
       *type = ViewHostMsg_AccessibilityNotification_Type::
           NOTIFICATION_TYPE_CHECK_STATE_CHANGED;
       break;
     case WebKit::WebAccessibilityNotificationChildrenChanged:
       *type = ViewHostMsg_AccessibilityNotification_Type::
@@ skipping 99 matching lines @@
       browser_window_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(accessibility_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       geolocation_dispatcher_(NULL),
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       accessibility_ack_pending_(false),
       p2p_socket_dispatcher_(NULL),
       session_storage_namespace_id_(session_storage_namespace_id) {
-
-  ClearBlockedContentSettings();
-
   routing_id_ = routing_id;
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   webwidget_ = WebView::create(this);
 
   if (counter) {
     shared_popup_counter_ = counter;
     shared_popup_counter_->data++;
     decrement_shared_popup_at_destruction_ = true;
@@ skipping 240 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_Paste, OnPaste)
     IPC_MESSAGE_HANDLER(ViewMsg_Replace, OnReplace)
     IPC_MESSAGE_HANDLER(ViewMsg_Delete, OnDelete)
     IPC_MESSAGE_HANDLER(ViewMsg_SelectAll, OnSelectAll)
     IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt, OnCopyImageAt)
     IPC_MESSAGE_HANDLER(ViewMsg_ExecuteEditCommand, OnExecuteEditCommand)
     IPC_MESSAGE_HANDLER(ViewMsg_Find, OnFind)
     IPC_MESSAGE_HANDLER(ViewMsg_StopFinding, OnStopFinding)
     IPC_MESSAGE_HANDLER(ViewMsg_FindReplyACK, OnFindReplyAck)
     IPC_MESSAGE_HANDLER(ViewMsg_Zoom, OnZoom)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetContentSettingsForLoadingURL,
-                        OnSetContentSettingsForLoadingURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevel, OnSetZoomLevel)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingURL,
                         OnSetZoomLevelForLoadingURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding, OnSetPageEncoding)
     IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault,
                         OnResetPageEncodingToDefault)
     IPC_MESSAGE_HANDLER(ViewMsg_DownloadFavicon, OnDownloadFavicon)
     IPC_MESSAGE_HANDLER(ViewMsg_ScriptEvalRequest, OnScriptEvalRequest)
     IPC_MESSAGE_HANDLER(ViewMsg_CSSInsertRequest, OnCSSInsertRequest)
     IPC_MESSAGE_HANDLER(ViewMsg_ReservePageIDRange, OnReservePageIDRange)
@@ skipping 320 matching lines @@
   if (!node.isNull()) {
     if (IsEditableNode(node))
       // TODO(varunjain): Change webkit API to scroll a particular node into
       // view and use that API here instead.
       webview()->scrollFocusedNodeIntoView();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void RenderView::SetContentSettings(const ContentSettings& settings) {
-  current_content_settings_ = settings;
-}
-
 // Tell the embedding application that the URL of the active page has changed
 void RenderView::UpdateURL(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLRequest& original_request = ds->originalRequest();
   const WebURLResponse& response = ds->response();
 
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
@@ skipping 46 matching lines @@
   // entry had it at all times.
   const WebHistoryItem& item = frame->currentHistoryItem();
   if (!item.isNull()) {
     params.content_state = webkit_glue::HistoryItemToString(item);
   } else {
     params.content_state =
         webkit_glue::CreateHistoryStateForURL(GURL(request.url()));
   }
 
   if (!frame->parent()) {
     // Top-level navigation.

[pastarmovj, 2011/04/18 16:09:23]

Do you want to preserve one empty line here.

[jam, 2011/04/18 16:50:10]

Done.

-
-    // Clear "block" flags for the new page. This needs to happen before any of
-    // allowScripts(), allowImages(), 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();
-
-    // Set content settings. Default them from the parent window if one exists.
-    // This makes sure about:blank windows work as expected.
-    HostContentSettings::iterator host_content_settings =
-        host_content_settings_.find(GURL(request.url()));
-    if (host_content_settings != host_content_settings_.end()) {
-      SetContentSettings(host_content_settings->second);
-
-      // These content settings were merely recorded transiently for this load.
-      // We can erase them now.  If at some point we reload this page, the
-      // browser will send us new, up-to-date content settings.
-      host_content_settings_.erase(host_content_settings);
-    } else if (frame->opener()) {
-      // The opener's view is not guaranteed to be non-null (it could be
-      // detached from its page but not yet destructed).
-      if (WebView* opener_view = frame->opener()->view()) {
-        RenderView* opener = FromWebView(opener_view);
-        SetContentSettings(opener->current_content_settings_);
-      }
-    }
-
     // Set zoom level, but don't do it for full-page plugin since they don't use
     // the same zoom settings.
     HostZoomLevels::iterator host_zoom =
         host_zoom_levels_.find(GURL(request.url()));
     if (webview()->mainFrame()->document().isPluginDocument()) {
       // Reset the zoom levels for plugins.
       webview()->setZoomLevel(false, 0);
     } else {
       if (host_zoom != host_zoom_levels_.end())
         webview()->setZoomLevel(false, host_zoom->second);
@@ skipping 967 matching lines @@
 }
 
 void RenderView::frameDetached(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
 }
 
 void RenderView::willClose(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameWillClose(frame));
 }
 
-bool RenderView::allowImages(WebFrame* frame, bool enabled_per_settings) {
-  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 RenderView::allowPlugins(WebFrame* frame, bool enabled_per_settings) {
-  return WebFrameClient::allowPlugins(frame, enabled_per_settings);
-}
-
 void RenderView::loadURLExternally(
     WebFrame* frame, const WebURLRequest& request,
     WebNavigationPolicy policy) {
   GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
   if (policy == WebKit::WebNavigationPolicyDownload) {
     Send(new ViewHostMsg_DownloadUrl(routing_id_, request.url(), referrer));
   } else {
     OpenURL(request.url(), referrer, policy);
   }
 }
@@ skipping 738 matching lines @@
 }
 
 void RenderView::didRunInsecureContent(
     WebFrame* frame, const WebSecurityOrigin& origin, const WebURL& target) {
   Send(new ViewHostMsg_DidRunInsecureContent(
       routing_id_,
       origin.toString().utf8(),
       target));
 }
 
+bool RenderView::allowImages(WebFrame* frame, bool enabled_per_settings) {
+  ObserverListBase<RenderViewObserver>::Iterator it(observers_);
+  RenderViewObserver* observer;
+  while ((observer = it.GetNext()) != NULL)
+    if (!observer->AllowImages(frame, enabled_per_settings))
+      return false;
+
+  return true;
+}
+
+bool RenderView::allowPlugins(WebFrame* frame, bool enabled_per_settings) {
+  ObserverListBase<RenderViewObserver>::Iterator it(observers_);
+  RenderViewObserver* observer;
+  while ((observer = it.GetNext()) != NULL)
+    if (!observer->AllowPlugins(frame, enabled_per_settings))
+      return false;
+
+  return true;
+}
+
 bool RenderView::allowScript(WebFrame* frame, bool enabled_per_settings) {
-  if (enabled_per_settings &&
-      AllowContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT))
-    return true;
+  ObserverListBase<RenderViewObserver>::Iterator it(observers_);
+  RenderViewObserver* observer;
+  while ((observer = it.GetNext()) != NULL)
+    if (!observer->AllowScript(frame, enabled_per_settings))
+      return false;
 
-  if (IsWhitelistedForContentSettings(frame))
-    return true;
-
-  return false;  // Other protocols fall through here.
+  return true;
 }
 
 bool RenderView::allowDatabase(
     WebFrame* frame, const WebString& name, const WebString& display_name,
     unsigned long estimated_size) {
   WebSecurityOrigin origin = frame->securityOrigin();
   if (origin.isEmpty())
     return false;  // Uninitialized document?
 
   bool result;
   if (!Send(new DatabaseHostMsg_Allow(routing_id_,
       origin.toString().utf8(), name, display_name, estimated_size, &result)))
     return false;
   Send(new ViewHostMsg_WebDatabaseAccessed(routing_id_,
                                            GURL(origin.toString().utf8()),
                                            name,
                                            display_name,
                                            estimated_size,
                                            !result));
   return result;
 }
 void RenderView::didNotAllowScript(WebKit::WebFrame* frame) {
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string());
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidNotAllowScript(frame));
 }
 
 void RenderView::didNotAllowPlugins(WebKit::WebFrame* frame) {
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidNotAllowPlugins(frame));
 }
 
 void RenderView::didExhaustMemoryAvailableForScript(WebFrame* frame) {
   Send(new ViewHostMsg_JSOutOfMemory(routing_id_));
 }
 
 void RenderView::didCreateScriptContext(WebFrame* frame) {
   content::GetContentClient()->renderer()->DidCreateScriptContext(frame);
 }
 
@@ skipping 531 matching lines @@
 }
 
 void RenderView::OnFindReplyAck() {
   // Check if there is any queued up request waiting to be sent.
   if (queued_find_reply_message_.get()) {
     // Send the search result over to the browser process.
     Send(queued_find_reply_message_.release());
   }
 }
 
-bool RenderView::AllowContentType(ContentSettingsType settings_type) {
-  // CONTENT_SETTING_ASK is only valid for cookies.
-  return current_content_settings_.settings[settings_type] !=
-    CONTENT_SETTING_BLOCK;
-}
-
-void RenderView::DidBlockContentType(ContentSettingsType settings_type,
-                                     const std::string& resource_identifier) {
-  if (!content_blocked_[settings_type]) {
-    content_blocked_[settings_type] = true;
-    Send(new ViewHostMsg_ContentBlocked(routing_id_, settings_type,
-                                        resource_identifier));
-  }
-}
-
-void RenderView::ClearBlockedContentSettings() {
-  for (size_t i = 0; i < arraysize(content_blocked_); ++i)
-    content_blocked_[i] = false;
-}
-
 WebPlugin* RenderView::CreatePepperPlugin(
     WebFrame* frame,
     const WebPluginParams& params,
     const FilePath& path,
     webkit::ppapi::PluginModule* pepper_module) {
   return new webkit::ppapi::WebPluginImpl(
       pepper_module, params, pepper_delegate_.AsWeakPtr());
 }
 
 WebPlugin* RenderView::CreateNPAPIPlugin(
@@ skipping 40 matching lines @@
   // Don't set zoom level for full-page plugin since they don't use the same
   // zoom settings.
   if (webview()->mainFrame()->document().isPluginDocument())
     return;
 
   webview()->hidePopups();
   webview()->setZoomLevel(false, zoom_level);
   zoomLevelChanged();
 }
 
-void RenderView::OnSetContentSettingsForLoadingURL(
-    const GURL& url,
-    const ContentSettings& content_settings) {
-  host_content_settings_[url] = content_settings;
-}
-
 void RenderView::OnSetZoomLevelForLoadingURL(const GURL& url,
                                              double zoom_level) {
   host_zoom_levels_[url] = zoom_level;
 }
 
 void RenderView::OnSetPageEncoding(const std::string& encoding_name) {
   webview()->setPageEncoding(WebString::fromUTF8(encoding_name));
 }
 
 void RenderView::OnResetPageEncodingToDefault() {
@@ skipping 1050 matching lines @@
     const webkit_glue::CustomContextMenuContext& custom_context) {
   if (custom_context.is_pepper_menu)
     pepper_delegate_.OnContextMenuClosed(custom_context);
   else
     context_menu_node_.reset();
 }
 
 void RenderView::OnNetworkStateChanged(bool online) {
   WebNetworkStateNotifier::setOnLine(online);
 }