Switch ContentSettingsObserver to be a RenderFrameObserver instead of a RenderViewObserver

chrome/browser/content_settings/tab_specific_content_settings.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/browser/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "net/cookies/canonical_cookie.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::RenderViewHost;
@@ skipping 49 matching lines @@
   if (!view)
     return NULL;
 
   WebContents* web_contents = WebContents::FromRenderViewHost(view);
   if (!web_contents)
     return NULL;
 
   return TabSpecificContentSettings::FromWebContents(web_contents);
 }
 
+TabSpecificContentSettings* TabSpecificContentSettings::GetForFrame(
+    int render_process_id, int render_frame_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  content::RenderFrameHost* frame = content::RenderFrameHost::FromID(
+      render_process_id, render_frame_id);
+  if (!frame)
+    return NULL;
+
+  WebContents* web_contents = WebContents::FromRenderFrameHost(frame);
+  if (!web_contents)
+    return NULL;
+
+  return TabSpecificContentSettings::FromWebContents(web_contents);
+}
+
 // static
 void TabSpecificContentSettings::CookiesRead(int render_process_id,
                                              int render_view_id,
                                              const GURL& url,
                                              const GURL& frame_url,
                                              const net::CookieList& cookie_list,
                                              bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
   if (settings) {
@@ skipping 14 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
   if (settings)
     settings->OnCookieChanged(url, frame_url, cookie_line, options,
                               blocked_by_policy);
 }
 
 // static
 void TabSpecificContentSettings::WebDatabaseAccessed(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     const GURL& url,
     const base::string16& name,
     const base::string16& display_name,
     bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
+  TabSpecificContentSettings* settings = GetForFrame(
+      render_process_id, render_frame_id);
+
+  // TODO(jam): remove this once WorkerProcessHost knows the RenderFrame IDs for
+  // a shared worker, which needs SharedWorkerRepository to be per frame.
+  if (!settings)
+    settings = Get(render_process_id, render_frame_id);
+
   if (settings)
     settings->OnWebDatabaseAccessed(url, name, display_name, blocked_by_policy);
 }
 
 // static
 void TabSpecificContentSettings::DOMStorageAccessed(int render_process_id,
-                                                    int render_view_id,
+                                                    int render_frame_id,
                                                     const GURL& url,
                                                     bool local,
                                                     bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
+  TabSpecificContentSettings* settings = GetForFrame(
+      render_process_id, render_frame_id);
   if (settings)
     settings->OnLocalStorageAccessed(url, local, blocked_by_policy);
 }
 
 // static
-void TabSpecificContentSettings::IndexedDBAccessed(int render_process_id,
-                                                   int render_view_id,
-                                                   const GURL& url,
-                                                   const base::string16& description,
-                                                   bool blocked_by_policy) {
+void TabSpecificContentSettings::IndexedDBAccessed(
+    int render_process_id,
+    int render_frame_id,
+    const GURL& url,
+    const base::string16& description,
+    bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
+  TabSpecificContentSettings* settings = GetForFrame(
+      render_process_id, render_frame_id);
+
+  // TODO(jam): remove this once WorkerProcessHost knows the RenderFrame IDs for
+  // a shared worker, which needs SharedWorkerRepository to be per frame.
+  if (!settings)
+    settings = Get(render_process_id, render_frame_id);
+
   if (settings)
     settings->OnIndexedDBAccessed(url, description, blocked_by_policy);
 }
 
 // static
 void TabSpecificContentSettings::FileSystemAccessed(int render_process_id,
-                                                    int render_view_id,
+                                                    int render_frame_id,
                                                     const GURL& url,
                                                     bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
+  TabSpecificContentSettings* settings = GetForFrame(
+      render_process_id, render_frame_id);
+
+  // TODO(jam): remove this once WorkerProcessHost knows the RenderFrame IDs for
+  // a shared worker, which needs SharedWorkerRepository to be per frame.
+  if (!settings)
+    settings = Get(render_process_id, render_frame_id);
+
   if (settings)
     settings->OnFileSystemAccessed(url, blocked_by_policy);
 }
 
 bool TabSpecificContentSettings::IsContentBlocked(
     ContentSettingsType content_type) const {
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by ContentSettingGeolocationImageModel";
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
       << "Notifications settings handled by "
@@ skipping 398 matching lines @@
 }
 
 void TabSpecificContentSettings::SetPepperBrokerAllowed(bool allowed) {
   if (allowed) {
     OnContentAllowed(CONTENT_SETTINGS_TYPE_PPAPI_BROKER);
   } else {
     OnContentBlocked(CONTENT_SETTINGS_TYPE_PPAPI_BROKER);
   }
 }
 
-void TabSpecificContentSettings::RenderViewForInterstitialPageCreated(
-    RenderViewHost* render_view_host) {
+void TabSpecificContentSettings::RenderFrameForInterstitialPageCreated(
+    content::RenderFrameHost* render_frame_host) {
   // We want to tell the renderer-side code to ignore content settings for this
   // page.
-  render_view_host->Send(new ChromeViewMsg_SetAsInterstitial(
-      render_view_host->GetRoutingID()));
+  render_frame_host->Send(new ChromeViewMsg_SetAsInterstitial(
+      render_frame_host->GetRoutingID()));
 }
 
 bool TabSpecificContentSettings::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(TabSpecificContentSettings, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ContentBlocked, OnContentBlocked)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 73 matching lines @@
 }
 
 void TabSpecificContentSettings::RemoveSiteDataObserver(
     SiteDataObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void TabSpecificContentSettings::NotifySiteDataObservers() {
   FOR_EACH_OBSERVER(SiteDataObserver, observer_list_, OnSiteDataAccessed());
 }