Switch ContentSettingsObserver to be a RenderFrameObserver instead of a RenderViewObserver

chrome/renderer/content_settings_observer.cc

 // Copyright (c) 2012 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 "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "webkit/child/weburlresponse_extradata_impl.h"
@@ skipping 110 matching lines @@
       return it->setting;
     }
   }
   NOTREACHED();
   return CONTENT_SETTING_DEFAULT;
 }
 
 }  // namespace
 
 ContentSettingsObserver::ContentSettingsObserver(
-    content::RenderView* render_view,
+    content::RenderFrame* render_frame,
     extensions::Dispatcher* extension_dispatcher)
-    : content::RenderViewObserver(render_view),
-      content::RenderViewObserverTracker<ContentSettingsObserver>(render_view),
+    : content::RenderFrameObserver(render_frame),
+      content::RenderFrameObserverTracker<ContentSettingsObserver>(
+          render_frame),
       extension_dispatcher_(extension_dispatcher),
       allow_displaying_insecure_content_(false),
       allow_running_insecure_content_(false),
       content_setting_rules_(NULL),
       is_interstitial_page_(false),
       npapi_plugins_blocked_(false) {
   ClearBlockedContentSettings();
-  render_view->GetWebView()->setPermissionClient(this);
 }
 
 ContentSettingsObserver::~ContentSettingsObserver() {
 }
 
 void ContentSettingsObserver::SetContentSettingRules(
     const RendererContentSettingRules* content_setting_rules) {
   content_setting_rules_ = content_setting_rules;
 }
 
 bool ContentSettingsObserver::IsPluginTemporarilyAllowed(
     const std::string& identifier) {
   // If the empty string is in here, it means all plug-ins are allowed.
   // TODO(bauerb): Remove this once we only pass in explicit identifiers.
   return (temporarily_allowed_plugins_.find(identifier) !=
           temporarily_allowed_plugins_.end()) ||
          (temporarily_allowed_plugins_.find(std::string()) !=
           temporarily_allowed_plugins_.end());
 }
 
 void ContentSettingsObserver::DidBlockContentType(
     ContentSettingsType settings_type) {
   if (!content_blocked_[settings_type]) {
     content_blocked_[settings_type] = true;
     Send(new ChromeViewHostMsg_ContentBlocked(routing_id(), settings_type));
   }
 }
 
+void ContentSettingsObserver::WebFrameCreated(blink::WebFrame* frame) {
+  frame->setPermissionClient(this);
+}
+
 bool ContentSettingsObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAsInterstitial, OnSetAsInterstitial)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_NPAPINotSupported, OnNPAPINotSupported)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowDisplayingInsecureContent,
                         OnSetAllowDisplayingInsecureContent)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowRunningInsecureContent,
                         OnSetAllowRunningInsecureContent)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_ReloadFrame, OnReloadFrame);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
 
   // Don't swallow LoadBlockedPlugins messages, as they're sent to every
   // blocked plugin.
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_LoadBlockedPlugins, OnLoadBlockedPlugins)
   IPC_END_MESSAGE_MAP()
@@ skipping 164 matching lines @@
       local, &result));
   cached_storage_permissions_[key] = result;
   return result;
 }
 
 bool ContentSettingsObserver::allowReadFromClipboard(WebFrame* frame,
                                                      bool default_value) {
   bool allowed = false;
   // TODO(dcheng): Should we consider a toURL() method on WebSecurityOrigin?
   Send(new ChromeViewHostMsg_CanTriggerClipboardRead(
-      routing_id(), GURL(frame->document().securityOrigin().toString().utf8()),
-      &allowed));
+      GURL(frame->document().securityOrigin().toString().utf8()), &allowed));
   return allowed;
 }
 
 bool ContentSettingsObserver::allowWriteToClipboard(WebFrame* frame,
                                                     bool default_value) {
   bool allowed = false;
   Send(new ChromeViewHostMsg_CanTriggerClipboardWrite(
-      routing_id(), GURL(frame->document().securityOrigin().toString().utf8()),
-      &allowed));
+      GURL(frame->document().securityOrigin().toString().utf8()), &allowed));
   return allowed;
 }
 
 #if defined(WEBPERMISSIONCLIENT_USES_FRAME_FOR_ALL_METHODS)
 bool ContentSettingsObserver::allowWebComponents(WebFrame* frame,
                                                  bool defaultValue) {
   if (defaultValue)
     return true;
 
   WebSecurityOrigin origin = frame->document().securityOrigin();
@@ skipping 179 matching lines @@
     DidBlockContentType(CONTENT_SETTINGS_TYPE_MIXEDSCRIPT);
     return false;
   }
 
   return true;
 }
 
 bool ContentSettingsObserver::allowWebGLDebugRendererInfo(WebFrame* frame) {
   bool allowed = false;
   Send(new ChromeViewHostMsg_IsWebGLDebugRendererInfoAllowed(
-      routing_id(),
       GURL(frame->top()->document().securityOrigin().toString().utf8()),
       &allowed));
   return allowed;
 }
 
 void ContentSettingsObserver::didNotAllowPlugins(WebFrame* frame) {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS);
 }
 
 void ContentSettingsObserver::didNotAllowScript(WebFrame* frame) {
@@ skipping 12 matching lines @@
 void ContentSettingsObserver::OnSetAsInterstitial() {
   is_interstitial_page_ = true;
 }
 
 void ContentSettingsObserver::OnNPAPINotSupported() {
   npapi_plugins_blocked_ = true;
 }
 
 void ContentSettingsObserver::OnSetAllowDisplayingInsecureContent(bool allow) {
   allow_displaying_insecure_content_ = allow;
-  WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
-  if (main_frame)
-    main_frame->reload();
 }
 
 void ContentSettingsObserver::OnSetAllowRunningInsecureContent(bool allow) {
   allow_running_insecure_content_ = allow;
   OnSetAllowDisplayingInsecureContent(allow);
 }
 
+void ContentSettingsObserver::OnReloadFrame() {
+  // TODO(jam): once --site-per-process is default this will just be
+  // render_frame()->GetWebFrame()->reload().
+  WebFrame* main_frame =
+      render_frame()->GetRenderView()->GetWebView()->mainFrame();
+  if (main_frame)
+    main_frame->reload();
+}
 
 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();
 }
 
 const extensions::Extension* ContentSettingsObserver::GetExtension(
     const WebSecurityOrigin& origin) const {
@@ skipping 38 matching lines @@
   if (EqualsASCII(origin.protocol(), chrome::kChromeDevToolsScheme))
     return true;  // DevTools UI elements should still work.
 
   if (EqualsASCII(origin.protocol(), extensions::kExtensionScheme))
     return true;
 
   if (EqualsASCII(origin.protocol(), chrome::kChromeInternalScheme))
     return true;
 
   // TODO(creis, fsamuel): Remove this once the concept of swapped out
-  // RenderViews goes away.
+  // RenderFrames goes away.
   if (document_url == GURL(content::kSwappedOutURL))
     return true;
 
   // If the scheme is file:, an empty file name indicates a directory listing,
   // which requires JavaScript to function properly.
   if (EqualsASCII(origin.protocol(), chrome::kFileScheme)) {
     return document_url.SchemeIs(chrome::kFileScheme) &&
            document_url.ExtractFileName().empty();
   }
 
   return false;
 }