Support "always allow" for runtime script execution

chrome/browser/extensions/extension_context_menu_model.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/extension_context_menu_model.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/extensions/active_script_controller.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/manifest_constants.h"
+#include "extensions/common/permissions/permission_set.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 using extensions::Extension;
 
 ExtensionContextMenuModel::ExtensionContextMenuModel(const Extension* extension,
@@ skipping 67 matching lines @@
     return;
 
   switch (command_id) {
     case NAME: {
       OpenURLParams params(extensions::ManifestURL::GetHomepageURL(extension),
                            Referrer(), NEW_FOREGROUND_TAB,
                            content::PAGE_TRANSITION_LINK, false);
       browser_->OpenURL(params);
       break;
     }
+    case ALWAYS_ALLOW: {
+      content::WebContents* web_contents =
+          browser_->tab_strip_model()->GetActiveWebContents();
+
+      extensions::ActiveScriptController* script_controller =
+          extensions::ActiveScriptController::GetForWebContents(web_contents);
+
+      // Allow current tab to run injection.

[Devlin, 2014/07/15 22:11:01]

Let's move this logic into ActiveScriptController - that's where most of the
rest is, and it avoids the slight hack of saying OnActiveTabPermissionGranted().

+      script_controller->OnActiveTabPermissionGranted(extension);

[gpdavis, 2014/07/15 21:56:38]

Grant active tab permission so that the page action disappears as if it were
left clicked.

+
+      GURL url = web_contents->GetLastCommittedURL();
+      extensions::URLPatternSet new_hosts;
+      URLPattern pattern(extensions::UserScript::ValidUserScriptSchemes());
+
+      pattern.SetScheme(url.scheme());
+      pattern.SetHost(url.host());
+      pattern.SetPath("/*");
+      LOG(WARNING) << "Adding pattern: " << pattern.GetAsString();
+      new_hosts.AddPattern(pattern);
+
+      scoped_refptr<extensions::PermissionSet> new_permissions =
+          new extensions::PermissionSet(extensions::APIPermissionSet(),
+                                        extensions::ManifestPermissionSet(),
+                                        extensions::URLPatternSet(),
+                                        new_hosts);
+
+      extensions::PermissionsUpdater updater(profile_);
+      updater.AddPermissions(extension, new_permissions.get());

[gpdavis, 2014/07/15 21:56:38]

Add current permissions for this session, since persisted permissions get loaded
at startup.

+
+      extensions::ExtensionPrefs* prefs =
+          extensions::ExtensionPrefs::Get(web_contents->GetBrowserContext());
+      prefs->ClearPersistedPermissions(extension);
+      prefs->AddPersistedPermission(extension, &pattern);

[gpdavis, 2014/07/15 21:56:37]

Currently, I have this clearing persisted permissions before adding so that it
doesn't get cluttered during testing.

+      break;
+    }

[gpdavis, 2014/07/15 21:56:38]

I'm not sure how much of this code belongs in this switch statement.  I figured
I could get some feedback on how to refactor this so that this file needs fewer
includes, and this case can simply make a couple of function calls to do what it
needs to do.

     case CONFIGURE:
       DCHECK(!extensions::ManifestURL::GetOptionsPage(extension).is_empty());
       extensions::ExtensionTabUtil::OpenOptionsPage(extension, browser_);
       break;
     case HIDE: {
       extensions::ExtensionActionAPI::SetBrowserActionVisibility(
           extensions::ExtensionPrefs::Get(profile_), extension->id(), false);
       break;
     }
     case UNINSTALL: {
@@ skipping 43 matching lines @@
   extension_action_ = extension_action_manager->GetBrowserAction(*extension);
   if (!extension_action_)
     extension_action_ = extension_action_manager->GetPageAction(*extension);
 
   std::string extension_name = extension->name();
   // Ampersands need to be escaped to avoid being treated like
   // mnemonics in the menu.
   base::ReplaceChars(extension_name, "&", "&&", &extension_name);
   AddItem(NAME, base::UTF8ToUTF16(extension_name));
   AddSeparator(ui::NORMAL_SEPARATOR);
+
+  // Add the "Always Allow" item for adding persisted permissions for script
+  // injections.
+  // TODO: Only add this item if the current page does not match any
+  // persisted permissions.
+  if (!extension_action_manager->GetBrowserAction(*extension) &&
+      extension->GetManifestData(extensions::manifest_keys::kContentScripts))
+    AddItemWithStringId(ALWAYS_ALLOW, IDS_EXTENSIONS_ALWAYS_ALLOW);

[gpdavis, 2014/07/15 21:56:38]

Any suggestions on a clean way to resolve this TODO?  If the extension has a
page action and has content scripts permission, this item will show up by
default.  But if the extension already has permission to inject on the current
URL, this shouldn't show up.

+
   AddItemWithStringId(CONFIGURE, IDS_EXTENSIONS_OPTIONS_MENU_ITEM);
   AddItem(UNINSTALL, l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNINSTALL));
   if (extension_action_manager->GetBrowserAction(*extension))
     AddItemWithStringId(HIDE, IDS_EXTENSIONS_HIDE_BUTTON);
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddItemWithStringId(MANAGE, IDS_MANAGE_EXTENSION);
 }
 
 const Extension* ExtensionContextMenuModel::GetExtension() const {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   return extension_service->GetExtensionById(extension_id_, false);
 }