[Extensions] Propagate activeTab hosts to extension background pages

chrome/browser/extensions/active_tab_permission_granter.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/extensions/active_tab_permission_granter.h"
 
 #include "chrome/browser/extensions/active_script_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/process_manager.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/user_script.h"
 #include "url/gurl.h"
 
-using content::RenderProcessHost;
-using content::WebContentsObserver;
+namespace extensions {
 
-namespace extensions {
+namespace {
+
+using CreateMessageFunction = base::Callback<IPC::Message*(bool)>;
+
+// Creates a new IPC message for updating tab-specific permissions.
+IPC::Message* CreateUpdateMessage(const GURL& visible_url,
+                                  const std::string& extension_id,
+                                  const URLPatternSet& new_hosts,
+                                  int tab_id,
+                                  bool update_whitelist) {
+  return new ExtensionMsg_UpdateTabSpecificPermissions(
+      visible_url, extension_id, new_hosts, update_whitelist, tab_id);
+}
+
+// Creates a new IPC message for clearing tab-specific permissions.
+IPC::Message* CreateClearMessage(const std::vector<std::string>& ids,
+                                 int tab_id,
+                                 bool update_whitelist) {
+  return new ExtensionMsg_ClearTabSpecificPermissions(
+      ids, update_whitelist, tab_id);
+}
+
+// Sends a message exactly once to each render process host owning one of the
+// given |view_hosts| and |tab_process|. If |tab_process| doesn't own any of the
+// |view_hosts|, it will not be signaled to update its origin whitelist.
+void SendMessageToProcesses(
+    const std::set<content::RenderViewHost*>& view_hosts,
+    content::RenderProcessHost* tab_process,
+    const CreateMessageFunction& create_message) {
+  std::set<content::RenderProcessHost*> sent_to_hosts;
+  for (content::RenderViewHost* view_host : view_hosts) {
+    content::RenderProcessHost* process_host = view_host->GetProcess();
+    if (sent_to_hosts.count(process_host) == 0) {
+      // Extension processes have to update the origin whitelists.
+      process_host->Send(create_message.Run(true));
+      sent_to_hosts.insert(view_host->GetProcess());
+    }
+  }
+  // If the tab wasn't one of those processes already updated (it likely
+  // wasn't), update it. Tabs don't need to update the origin whitelist.
+  if (sent_to_hosts.count(tab_process) == 0)
+    tab_process->Send(create_message.Run(false));
+}
+
+}  // namespace
 
 ActiveTabPermissionGranter::ActiveTabPermissionGranter(
     content::WebContents* web_contents,
     int tab_id,
     Profile* profile)
-    : WebContentsObserver(web_contents),
+    : content::WebContentsObserver(web_contents),
       tab_id_(tab_id),
       extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
 }
 
 ActiveTabPermissionGranter::~ActiveTabPermissionGranter() {}
 
 void ActiveTabPermissionGranter::GrantIfRequested(const Extension* extension) {
   if (granted_extensions_.Contains(extension->id()))
     return;
@@ skipping 18 matching lines @@
 
   if (!new_apis.empty() || !new_hosts.is_empty()) {
     granted_extensions_.Insert(extension);
     scoped_refptr<const PermissionSet> new_permissions =
         new PermissionSet(new_apis, ManifestPermissionSet(),
                           new_hosts, URLPatternSet());
     permissions_data->UpdateTabSpecificPermissions(tab_id_, new_permissions);
     const content::NavigationEntry* navigation_entry =
         web_contents()->GetController().GetVisibleEntry();
     if (navigation_entry) {
-      content::RenderViewHost* render_view_host =
-          web_contents()->GetRenderViewHost();
-      render_view_host->Send(new ExtensionMsg_UpdateTabSpecificPermissions(
-          render_view_host->GetRoutingID(),
-          navigation_entry->GetURL(),
-          extension->id(),
-          new_hosts));
+      // We update all extension render views with the new tab permissions, and
+      // also the tab itself.
+      CreateMessageFunction update_message =
+          base::Bind(&CreateUpdateMessage,
+                     navigation_entry->GetURL(),
+                     extension->id(),
+                     new_hosts,
+                     tab_id_);
+      SendMessageToProcesses(
+          ProcessManager::Get(web_contents()->GetBrowserContext())->
+              GetRenderViewHostsForExtension(extension->id()),
+          web_contents()->GetRenderProcessHost(),
+          update_message);
+
       // If more things ever need to know about this, we should consider making
       // an observer class.
       // It's important that this comes after the IPC is sent to the renderer,
       // so that any tasks executing in the renderer occur after it has the
       // updated permissions.
       ActiveScriptController::GetForWebContents(web_contents())
           ->OnActiveTabPermissionGranted(extension);
     }
   }
 }
@@ skipping 35 matching lines @@
     UnloadedExtensionInfo::Reason reason) {
   // Note: don't need to clear the permissions (nor tell the renderer about it)
   // because it's being unloaded anyway.
   granted_extensions_.Remove(extension->id());
 }
 
 void ActiveTabPermissionGranter::ClearActiveExtensionsAndNotify() {
   if (granted_extensions_.is_empty())
     return;
 
+  std::set<content::RenderViewHost*> view_hosts;
   std::vector<std::string> extension_ids;
-
-  for (ExtensionSet::const_iterator it = granted_extensions_.begin();
-       it != granted_extensions_.end(); ++it) {
-    it->get()->permissions_data()->ClearTabSpecificPermissions(tab_id_);
-    extension_ids.push_back((*it)->id());
+  ProcessManager* process_manager =
+      ProcessManager::Get(web_contents()->GetBrowserContext());
+  for (const scoped_refptr<const Extension>& extension : granted_extensions_) {
+    extension->permissions_data()->ClearTabSpecificPermissions(tab_id_);
+    extension_ids.push_back(extension->id());
+    std::set<content::RenderViewHost*> extension_view_hosts =
+        process_manager->GetRenderViewHostsForExtension(extension->id());
+    view_hosts.insert(extension_view_hosts.begin(), extension_view_hosts.end());
   }
 
-  content::RenderViewHost* render_view_host =
-      web_contents()->GetRenderViewHost();
-  render_view_host->Send(new ExtensionMsg_ClearTabSpecificPermissions(
-          render_view_host->GetRoutingID(), extension_ids));
+  CreateMessageFunction clear_message =
+      base::Bind(&CreateClearMessage, extension_ids, tab_id_);
+  SendMessageToProcesses(view_hosts,
+                         web_contents()->GetRenderProcessHost(),
+                         clear_message);
+
   granted_extensions_.Clear();
 }
 
 }  // namespace extensions