Switch ContentSettingsObserver to be a RenderFrameObserver instead of a RenderViewObserver

content/browser/web_contents/web_contents_impl.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 "content/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 261 matching lines @@
 }
 
 // Helper function for retrieving all the sites in a frame tree.
 bool CollectSites(BrowserContext* context,
                   std::set<GURL>* sites,
                   FrameTreeNode* node) {
   sites->insert(SiteInstance::GetSiteForURL(context, node->current_url()));
   return true;
 }
 
+bool ForEachFrameInternal(
+    const base::Callback<void(RenderFrameHost*)>& on_frame,
+    FrameTreeNode* node) {
+  on_frame.Run(node->render_frame_host());
+  return true;
+}
+
+void SendToAllFramesInternal(IPC::Message* message, RenderFrameHost* rfh) {
+  IPC::Message* message_copy = new IPC::Message(*message);
+  message_copy->set_routing_id(rfh->GetRoutingID());
+  rfh->Send(message_copy);
+}
+
 }  // namespace
 
 WebContents* WebContents::Create(const WebContents::CreateParams& params) {
   return WebContentsImpl::CreateWithOpener(
       params, static_cast<WebContentsImpl*>(params.opener));
 }
 
 WebContents* WebContents::CreateWithSessionStorage(
     const WebContents::CreateParams& params,
     const SessionStorageNamespaceMap& session_storage_namespace_map) {
@@ skipping 22 matching lines @@
       g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
       return;
     }
   }
 }
 
 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
   return rvh->GetDelegate()->GetAsWebContents();
 }
 
+WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
+  RenderFrameHostImpl* rfh_impl = static_cast<RenderFrameHostImpl*>(rfh);
+  if (!rfh_impl)
+    return NULL;
+  return rfh_impl->delegate()->GetAsWebContents();
+}
+
 // WebContentsImpl::DestructionObserver ----------------------------------------
 
 class WebContentsImpl::DestructionObserver : public WebContentsObserver {
  public:
   DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
       : WebContentsObserver(watched_contents),
         owner_(owner) {
   }
 
   // WebContentsObserver:
@@ skipping 293 matching lines @@
 
 RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
   RenderViewHostImpl* host = GetRenderManager()->current_host();
   return host ? host->GetProcess() : NULL;
 }
 
 RenderFrameHost* WebContentsImpl::GetMainFrame() {
   return frame_tree_.root()->render_frame_host();
 }
 
+void WebContentsImpl::ForEachFrame(
+    const base::Callback<void(RenderFrameHost*)>& on_frame) {
+  frame_tree_.ForEach(base::Bind(&ForEachFrameInternal, on_frame));
+}
+
+void WebContentsImpl::SendToAllFrames(IPC::Message* message) {
+  ForEachFrame(base::Bind(&SendToAllFramesInternal, message));
+  delete message;
+}
+
 RenderViewHost* WebContentsImpl::GetRenderViewHost() const {
   return GetRenderManager()->current_host();
 }
 
 void WebContentsImpl::GetRenderViewHostAtPosition(
     int x,
     int y,
     const base::Callback<void(RenderViewHost*, int, int)>& callback) {
   BrowserPluginEmbedder* embedder = GetBrowserPluginEmbedder();
   if (embedder)
@@ skipping 220 matching lines @@
 uint64 WebContentsImpl::GetUploadSize() const {
   return upload_size_;
 }
 
 uint64 WebContentsImpl::GetUploadPosition() const {
   return upload_position_;
 }
 
 std::set<GURL> WebContentsImpl::GetSitesInTab() const {
   std::set<GURL> sites;
-  frame_tree_.ForEach(Bind(&CollectSites,
-                           base::Unretained(GetBrowserContext()),
-                           base::Unretained(&sites)));
+  frame_tree_.ForEach(base::Bind(&CollectSites,
+                                 base::Unretained(GetBrowserContext()),
+                                 base::Unretained(&sites)));
   return sites;
 }
 
 const std::string& WebContentsImpl::GetEncoding() const {
   return encoding_;
 }
 
 bool WebContentsImpl::DisplayedInsecureContent() const {
   return displayed_insecure_content_;
 }
@@ skipping 771 matching lines @@
   return GetRenderViewHost()->Send(message);
 }
 
 bool WebContentsImpl::NavigateToPendingEntry(
     NavigationController::ReloadType reload_type) {
   return NavigateToEntry(
       *NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry()),
       reload_type);
 }
 
-void WebContentsImpl::RenderViewForInterstitialPageCreated(
-    RenderViewHost* render_view_host) {
+void WebContentsImpl::RenderFrameForInterstitialPageCreated(
+    RenderFrameHost* render_frame_host) {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
-                    RenderViewForInterstitialPageCreated(render_view_host));
+                    RenderFrameForInterstitialPageCreated(render_frame_host));
 }
 
 void WebContentsImpl::AttachInterstitialPage(
     InterstitialPageImpl* interstitial_page) {
   DCHECK(interstitial_page);
   GetRenderManager()->set_interstitial_page(interstitial_page);
 
   // Cancel any visible dialogs so that they don't interfere with the
   // interstitial.
   if (dialog_manager_)
@@ skipping 1087 matching lines @@
                     observers_,
                     RenderFrameCreated(render_frame_host));
 }
 
 void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     RenderFrameDeleted(render_frame_host));
 }
 
+WebContents* WebContentsImpl::GetAsWebContents() {
+  return this;
+}
+
 RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
   return render_view_host_delegate_view_;
 }
 
 RenderViewHostDelegate::RendererManagement*
 WebContentsImpl::GetRendererManagementDelegate() {
   return GetRenderManager();
 }
 
 RendererPreferences WebContentsImpl::GetRendererPrefs(
     BrowserContext* browser_context) const {
   return renderer_preferences_;
 }
 
-WebContents* WebContentsImpl::GetAsWebContents() {
-  return this;
-}
-
 gfx::Rect WebContentsImpl::GetRootWindowResizerRect() const {
   if (delegate_)
     return delegate_->GetRootWindowResizerRect();
   return gfx::Rect();
 }
 
 void WebContentsImpl::RemoveBrowserPluginEmbedder() {
   if (browser_plugin_embedder_)
     browser_plugin_embedder_.reset();
 }
@@ skipping 976 matching lines @@
 }
 
 void WebContentsImpl::OnFrameRemoved(
     RenderViewHostImpl* render_view_host,
     int64 frame_id) {
    FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                      FrameDetached(render_view_host, frame_id));
 }
 
 }  // namespace content