[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_host.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;
 
@@ skipping 35 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));
+      std::set<content::RenderProcessHost*> hosts;
+      // We update the tabs renderer, as well as the extension's background page
+      // if one exists.
+      hosts.insert(web_contents()->GetRenderProcessHost());
+      ExtensionHost* background_page =
+          ProcessManager::Get(web_contents()->GetBrowserContext())->
+              GetBackgroundHostForExtension(extension->id());

[not at google - send to devlin, 2015/02/03 19:29:12]

What about if the event page hasn't started yet? For example, the following flow
seems pretty likely:

(1) Event page is not running, but it listens to browserAction.onClicked
(2) User clicks on browser action: grants permission, fires onClicked event
(3) This check returns NULL because there is no background host yet, so the tab
permissions aren't propagated

... and I don't see anything accounting for that. Seems like you may need to
augment ExtensionMsg_Loaded_Params.

This relates to a comment I made in dispatcher.cc.

[Devlin, 2015/02/04 22:26:02]

Good point. Done.

+      if (background_page)
+        hosts.insert(background_page->render_process_host());
+
+      for (content::RenderProcessHost* host : hosts) {
+        host->Send(new ExtensionMsg_UpdateTabSpecificPermissions(
+            navigation_entry->GetURL(),
+            extension->id(),
+            new_hosts,
+            tab_id_));
+      }
+
       // 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 36 matching lines @@
   // 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::vector<std::string> extension_ids;
+  std::set<content::RenderProcessHost*> hosts;
+  hosts.insert(web_contents()->GetRenderProcessHost());
 
+  ProcessManager* process_manager =
+      ProcessManager::Get(web_contents()->GetBrowserContext());
   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());
+    ExtensionHost* background_page =
+        process_manager->GetBackgroundHostForExtension(it->get()->id());
+    if (background_page)
+      hosts.insert(background_page->render_process_host());
   }
 
-  content::RenderViewHost* render_view_host =
-      web_contents()->GetRenderViewHost();
-  render_view_host->Send(new ExtensionMsg_ClearTabSpecificPermissions(
-          render_view_host->GetRoutingID(), extension_ids));
+  // Notify the tab and any extension background pages.
+  for (content::RenderProcessHost* host : hosts) {
+    host->Send(new ExtensionMsg_ClearTabSpecificPermissions(
+        extension_ids, tab_id_));
+  }
   granted_extensions_.Clear();
 }
 
 }  // namespace extensions