PS - Showing permission prompt for activeTab

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/extension_action_runner.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
@@ skipping 48 matching lines @@
       process_host->Send(create_message.Run(true));
       sent_to_hosts.insert(frame_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));
 }
 
+ActiveTabPermissionGranter::Delegate* g_delegate = nullptr;
+
 }  // namespace
 
 ActiveTabPermissionGranter::ActiveTabPermissionGranter(
     content::WebContents* web_contents,
     int tab_id,
     Profile* profile)
     : content::WebContentsObserver(web_contents),
       tab_id_(tab_id),
       extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
 }
 
 ActiveTabPermissionGranter::~ActiveTabPermissionGranter() {}
 
+// static
+void ActiveTabPermissionGranter::SetPlatformDelegate(Delegate* delegate) {
+  // Disallow setting it twice (but allow resetting - don't forget to free in
+  // that case).
+  CHECK(!g_delegate || !delegate);
+  g_delegate = delegate;
+}
+
 void ActiveTabPermissionGranter::GrantIfRequested(const Extension* extension) {
   if (granted_extensions_.Contains(extension->id()))
     return;
 
   APIPermissionSet new_apis;
   URLPatternSet new_hosts;
 
   const PermissionsData* permissions_data = extension->permissions_data();
 
+  bool active_tab_granted = !g_delegate ||
+      g_delegate->ActiveTabPermissionGranted(extension, web_contents());
   // If the extension requested all-hosts but has had it withheld, we grant it
   // active tab-style permissions, even if it doesn't have the activeTab
   // permission in the manifest.
-  if (permissions_data->HasAPIPermission(APIPermission::kActiveTab) ||
-      permissions_data->HasWithheldImpliedAllHosts()) {
+  if (active_tab_granted &&
+      (permissions_data->HasWithheldImpliedAllHosts() ||
+       permissions_data->HasAPIPermission(APIPermission::kActiveTab))) {
     new_hosts.AddOrigin(UserScript::ValidUserScriptSchemes(),
                         web_contents()->GetVisibleURL().GetOrigin());
     new_apis.insert(APIPermission::kTab);
   }
 
   if (permissions_data->HasAPIPermission(APIPermission::kTabCapture))

[Devlin, 2017/05/12 14:56:45]

do we want to gate this on whether or not we grant it as well?  (We might be
safe because kTabCapture might not be whitelisted, but that seems like a tenuous
guarantee.)

I think it might be cleaner to just do:
if (g_delegate && !g_delegate->ActiveTabPermissionGranted())
  return;  // Delegate refused permission.

[Ivan Šandrk, 2017/05/12 18:27:44]

kTabCapture is already dealt with[1], so I'd keep it as is here (so this only
affects the activeTab permission).

[1] chrome/browser/media/public_session_tab_capture_access_handler.cc

     new_apis.insert(APIPermission::kTabCaptureForTab);
 
   if (!new_apis.empty() || !new_hosts.is_empty()) {
     granted_extensions_.Insert(extension);
     PermissionSet new_permissions(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) {
@@ skipping 89 matching lines @@
   CreateMessageFunction clear_message =
       base::Bind(&CreateClearMessage, extension_ids, tab_id_);
   SendMessageToProcesses(frame_hosts,
                          web_contents()->GetRenderProcessHost(),
                          clear_message);
 
   granted_extensions_.Clear();
 }
 
 }  // namespace extensions