| // 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 <memory> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/json/json_reader.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/metrics/user_action_tester.h" |
| #include "build/chromeos_buildflags.h" |
| #include "chrome/app/chrome_command_ids.h" |
| #include "chrome/browser/extensions/chrome_extension_browser_constants.h" |
| #include "chrome/browser/extensions/context_menu_matcher.h" |
| #include "chrome/browser/extensions/extension_action_runner.h" |
| #include "chrome/browser/extensions/extension_action_test_util.h" |
| #include "chrome/browser/extensions/extension_service.h" |
| #include "chrome/browser/extensions/extension_service_test_base.h" |
| #include "chrome/browser/extensions/menu_manager.h" |
| #include "chrome/browser/extensions/menu_manager_factory.h" |
| #include "chrome/browser/extensions/permissions_test_util.h" |
| #include "chrome/browser/extensions/permissions_updater.h" |
| #include "chrome/browser/extensions/scripting_permissions_modifier.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/tabs/tab_strip_model.h" |
| #include "chrome/browser/ui/toolbar/toolbar_actions_model.h" |
| #include "chrome/common/extensions/api/context_menus.h" |
| #include "chrome/grit/chromium_strings.h" |
| #include "chrome/grit/generated_resources.h" |
| #include "chrome/test/base/test_browser_window.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/crx_file/id_util.h" |
| #include "content/public/browser/navigation_controller.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/test_renderer_host.h" |
| #include "content/public/test/web_contents_tester.h" |
| #include "extensions/browser/extension_dialog_auto_confirm.h" |
| #include "extensions/browser/extension_registry.h" |
| #include "extensions/browser/extension_system.h" |
| #include "extensions/browser/permissions_manager.h" |
| #include "extensions/browser/test_extension_registry_observer.h" |
| #include "extensions/browser/test_management_policy.h" |
| #include "extensions/common/api/extension_action/action_info.h" |
| #include "extensions/common/api/extension_action/action_info_test_util.h" |
| #include "extensions/common/extension_builder.h" |
| #include "extensions/common/extension_features.h" |
| #include "extensions/common/extensions_client.h" |
| #include "extensions/common/manifest.h" |
| #include "extensions/common/manifest_constants.h" |
| #include "extensions/common/manifest_handlers/options_page_info.h" |
| #include "extensions/common/mojom/manifest.mojom-shared.h" |
| #include "extensions/common/mojom/run_location.mojom-shared.h" |
| #include "extensions/common/permissions/permissions_data.h" |
| #include "extensions/common/value_builder.h" |
| #include "extensions/test/permissions_manager_waiter.h" |
| #include "net/disk_cache/blockfile/disk_format_base.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/display/test/scoped_screen_override.h" |
| #include "ui/display/test/test_screen.h" |
| #include "ui/gfx/image/image.h" |
| #include "url/origin.h" |
| |
| #if BUILDFLAG(IS_CHROMEOS_ASH) |
| #include "chrome/browser/ash/app_mode/kiosk_app_manager.h" |
| #endif |
| |
| namespace extensions { |
| |
| using display::test::ScopedScreenOverride; |
| using mojom::ManifestLocation; |
| using ContextMenuSource = ExtensionContextMenuModel::ContextMenuSource; |
| using MenuEntries = ExtensionContextMenuModel::MenuEntries; |
| |
| const MenuEntries kGrantAllExtensions = |
| ExtensionContextMenuModel::PAGE_ACCESS_ALL_EXTENSIONS_GRANTED; |
| const MenuEntries kBlockAllExtensions = |
| ExtensionContextMenuModel::PAGE_ACCESS_ALL_EXTENSIONS_BLOCKED; |
| const MenuEntries kPageAccessSubmenu = |
| ExtensionContextMenuModel::PAGE_ACCESS_SUBMENU; |
| const MenuEntries kOnClick = |
| ExtensionContextMenuModel::PAGE_ACCESS_RUN_ON_CLICK; |
| const MenuEntries kOnSite = ExtensionContextMenuModel::PAGE_ACCESS_RUN_ON_SITE; |
| const MenuEntries kOnAllSites = |
| ExtensionContextMenuModel::PAGE_ACCESS_RUN_ON_ALL_SITES; |
| const MenuEntries kPermissionsPage = |
| ExtensionContextMenuModel::PAGE_ACCESS_PERMISSIONS_PAGE; |
| const MenuEntries kLearnMore = |
| ExtensionContextMenuModel::PAGE_ACCESS_LEARN_MORE; |
| |
| namespace { |
| |
| void Increment(int* i, bool granted) { |
| if (!granted) |
| return; |
| CHECK(i); |
| ++(*i); |
| } |
| |
| MenuItem::Context MenuItemContextForActionType(ActionInfo::Type type) { |
| MenuItem::Context context = MenuItem::ALL; |
| switch (type) { |
| case ActionInfo::TYPE_BROWSER: |
| context = MenuItem::BROWSER_ACTION; |
| break; |
| case ActionInfo::TYPE_PAGE: |
| context = MenuItem::PAGE_ACTION; |
| break; |
| case ActionInfo::TYPE_ACTION: |
| context = MenuItem::ACTION; |
| break; |
| } |
| |
| return context; |
| } |
| |
| scoped_refptr<const Extension> BuildExtensionWithActionType( |
| ActionInfo::Type type) { |
| return ExtensionBuilder("extension") |
| .SetAction(type) |
| .SetManifestVersion(GetManifestVersionForActionType(type)) |
| .Build(); |
| } |
| |
| // Label for test extension menu item. |
| const char* kTestExtensionItemLabel = "test-ext-item"; |
| |
| std::string item_label() { |
| return kTestExtensionItemLabel; |
| } |
| |
| class MenuBuilder { |
| public: |
| MenuBuilder(scoped_refptr<const Extension> extension, |
| Browser* browser, |
| MenuManager* menu_manager) |
| : extension_(extension), |
| browser_(browser), |
| menu_manager_(menu_manager), |
| cur_id_(0) {} |
| |
| MenuBuilder(const MenuBuilder&) = delete; |
| MenuBuilder& operator=(const MenuBuilder&) = delete; |
| |
| ~MenuBuilder() {} |
| |
| std::unique_ptr<ExtensionContextMenuModel> BuildMenu() { |
| return std::make_unique<ExtensionContextMenuModel>( |
| extension_.get(), browser_, ExtensionContextMenuModel::PINNED, nullptr, |
| /* can_show_icon_in_toolbar=*/true, ContextMenuSource::kToolbarAction); |
| } |
| |
| void AddContextItem(MenuItem::Context context) { |
| MenuItem::Id id(false /* not incognito */, |
| MenuItem::ExtensionKey(extension_->id())); |
| id.uid = ++cur_id_; |
| menu_manager_->AddContextItem( |
| extension_.get(), |
| std::make_unique<MenuItem>(id, kTestExtensionItemLabel, |
| false, // check`ed |
| true, // visible |
| true, // enabled |
| MenuItem::NORMAL, |
| MenuItem::ContextList(context))); |
| } |
| |
| void SetItemVisibility(int item_id, bool visible) { |
| MenuItem::Id id(false /* not incognito */, |
| MenuItem::ExtensionKey(extension_->id())); |
| id.uid = item_id; |
| |
| menu_manager_->GetItemById(id)->set_visible(visible); |
| } |
| |
| void SetItemTitle(int item_id, const std::string& title) { |
| MenuItem::Id id(false /* not incognito */, |
| MenuItem::ExtensionKey(extension_->id())); |
| id.uid = item_id; |
| |
| menu_manager_->GetItemById(id)->set_title(title); |
| } |
| |
| private: |
| scoped_refptr<const Extension> extension_; |
| raw_ptr<Browser> browser_; |
| raw_ptr<MenuManager> menu_manager_; |
| int cur_id_; |
| }; |
| |
| // Returns the number of extension menu items that show up in |model|. |
| // For this test, all the extension items have same label |
| // |kTestExtensionItemLabel|. |
| int CountExtensionItems(const ExtensionContextMenuModel& model) { |
| std::u16string expected_label = base::ASCIIToUTF16(kTestExtensionItemLabel); |
| int num_items_found = 0; |
| int num_custom_found = 0; |
| for (size_t i = 0; i < model.GetItemCount(); ++i) { |
| std::u16string actual_label = model.GetLabelAt(i); |
| int command_id = model.GetCommandIdAt(i); |
| // If the command id is not visible, it should not be counted. |
| if (model.IsCommandIdVisible(command_id)) { |
| // The last character of |expected_label| can be the item number (e.g |
| // "test-ext-item" -> "test-ext-item1"). In checking that extensions items |
| // have the same label |kTestExtensionItemLabel|, the specific item number |
| // is ignored, [0, expected_label.size). |
| if (base::StartsWith(actual_label, expected_label, |
| base::CompareCase::SENSITIVE)) |
| ++num_items_found; |
| if (ContextMenuMatcher::IsExtensionsCustomCommandId(command_id)) |
| ++num_custom_found; |
| } |
| } |
| // The only custom extension items present on the menu should be those we |
| // added in the test. |
| EXPECT_EQ(num_items_found, num_custom_found); |
| return num_items_found; |
| } |
| |
| // Checks that the model has the extension items in the exact order specified by |
| // |item_number|. |
| void VerifyItems(const ExtensionContextMenuModel& model, |
| std::vector<std::string> item_number) { |
| size_t j = 0; |
| for (size_t i = 0; i < model.GetItemCount(); i++) { |
| int command_id = model.GetCommandIdAt(i); |
| if (ContextMenuMatcher::IsExtensionsCustomCommandId(command_id) && |
| model.IsCommandIdVisible(command_id)) { |
| ASSERT_LT(j, item_number.size()); |
| EXPECT_EQ(base::ASCIIToUTF16(item_label() + item_number[j]), |
| model.GetLabelAt(i)); |
| j++; |
| } |
| } |
| EXPECT_EQ(item_number.size(), j); |
| } |
| |
| } // namespace |
| |
| class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { |
| public: |
| enum class CommandState { |
| kAbsent, // The command is not present in the menu. |
| kEnabled, // The command is present, and enabled. |
| kDisabled, // The command is present, and disabled. |
| }; |
| |
| ExtensionContextMenuModelTest(); |
| |
| ExtensionContextMenuModelTest(const ExtensionContextMenuModelTest&) = delete; |
| ExtensionContextMenuModelTest& operator=( |
| const ExtensionContextMenuModelTest&) = delete; |
| |
| // Build an extension to pass to the menu constructor, with the action |
| // specified by |action_key|. |
| const Extension* AddExtension(const std::string& name, |
| const char* action_key, |
| ManifestLocation location); |
| const Extension* AddExtensionWithHostPermission( |
| const std::string& name, |
| const char* action_key, |
| ManifestLocation location, |
| const std::string& host_permission); |
| // TODO(devlin): Consolidate this with the methods above. |
| void InitializeAndAddExtension(const Extension& extension); |
| |
| Browser* GetBrowser(); |
| |
| MenuManager* CreateMenuManager(); |
| |
| // Adds a new tab with |url| to the tab strip, and returns the WebContents |
| // associated with it. |
| content::WebContents* AddTab(const GURL& url); |
| |
| // Returns the current state for the specified `command` in `menu`. |
| CommandState GetCommandState(const ExtensionContextMenuModel& menu, |
| int command) const; |
| |
| // Returns the current state for the specified page access |command|. |
| CommandState GetPageAccessCommandState(const ExtensionContextMenuModel& menu, |
| int command) const; |
| |
| // Returns true if the |menu| has the page access submenu at all. |
| bool HasPageAccessSubmenu(const ExtensionContextMenuModel& menu) const; |
| |
| // Returns true if the |menu| has a valid entry for the "can't access page" |
| // item. |
| bool HasCantAccessPageEntry(const ExtensionContextMenuModel& menu) const; |
| |
| void SetUp() override; |
| void TearDown() override; |
| |
| private: |
| std::unique_ptr<TestBrowserWindow> test_window_; |
| std::unique_ptr<Browser> browser_; |
| display::test::TestScreen test_screen_; |
| std::unique_ptr<ScopedScreenOverride> scoped_screen_override_; |
| }; |
| |
| ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() {} |
| |
| const Extension* ExtensionContextMenuModelTest::AddExtension( |
| const std::string& name, |
| const char* action_key, |
| ManifestLocation location) { |
| return AddExtensionWithHostPermission(name, action_key, location, |
| std::string()); |
| } |
| |
| const Extension* ExtensionContextMenuModelTest::AddExtensionWithHostPermission( |
| const std::string& name, |
| const char* action_key, |
| ManifestLocation location, |
| const std::string& host_permission) { |
| DictionaryBuilder manifest; |
| manifest.Set("name", name).Set("version", "1").Set("manifest_version", 2); |
| if (action_key) |
| manifest.Set(action_key, DictionaryBuilder().Build()); |
| if (!host_permission.empty()) |
| manifest.Set("permissions", ListBuilder().Append(host_permission).Build()); |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder() |
| .SetManifest(manifest.Build()) |
| .SetID(crx_file::id_util::GenerateId(name)) |
| .SetLocation(location) |
| .Build(); |
| if (!extension.get()) |
| ADD_FAILURE(); |
| service()->GrantPermissions(extension.get()); |
| service()->AddExtension(extension.get()); |
| return extension.get(); |
| } |
| |
| void ExtensionContextMenuModelTest::InitializeAndAddExtension( |
| const Extension& extension) { |
| PermissionsUpdater updater(profile()); |
| updater.InitializePermissions(&extension); |
| updater.GrantActivePermissions(&extension); |
| service()->AddExtension(&extension); |
| } |
| |
| Browser* ExtensionContextMenuModelTest::GetBrowser() { |
| if (!browser_) { |
| Browser::CreateParams params(profile(), true); |
| test_window_ = std::make_unique<TestBrowserWindow>(); |
| params.window = test_window_.get(); |
| browser_.reset(Browser::Create(params)); |
| } |
| return browser_.get(); |
| } |
| |
| MenuManager* ExtensionContextMenuModelTest::CreateMenuManager() { |
| return static_cast<MenuManager*>( |
| MenuManagerFactory::GetInstance()->SetTestingFactoryAndUse( |
| profile(), base::BindRepeating( |
| &MenuManagerFactory::BuildServiceInstanceForTesting))); |
| } |
| |
| content::WebContents* ExtensionContextMenuModelTest::AddTab(const GURL& url) { |
| std::unique_ptr<content::WebContents> contents( |
| content::WebContentsTester::CreateTestWebContents(profile(), nullptr)); |
| content::WebContents* raw_contents = contents.get(); |
| Browser* browser = GetBrowser(); |
| browser->tab_strip_model()->AppendWebContents(std::move(contents), true); |
| EXPECT_EQ(browser->tab_strip_model()->GetActiveWebContents(), raw_contents); |
| content::WebContentsTester* web_contents_tester = |
| content::WebContentsTester::For(raw_contents); |
| web_contents_tester->NavigateAndCommit(url); |
| return raw_contents; |
| } |
| |
| ExtensionContextMenuModelTest::CommandState |
| ExtensionContextMenuModelTest::GetCommandState( |
| const ExtensionContextMenuModel& menu, |
| int command_id) const { |
| bool is_present = menu.GetIndexOfCommandId(command_id).has_value(); |
| bool is_visible = menu.IsCommandIdVisible(command_id); |
| |
| // The command is absent if the menu entry is not present, or the entry is |
| // present and not visible. |
| if (!is_present || (is_present && !is_visible)) |
| return CommandState::kAbsent; |
| |
| // The command is disabled if the menu entry is present, visible and is not |
| // enabled. |
| bool is_enabled = menu.IsCommandIdEnabled(command_id); |
| if (is_present && is_visible && !is_enabled) |
| return CommandState::kDisabled; |
| |
| // Otherwise the command is enabled. |
| return CommandState::kEnabled; |
| } |
| |
| ExtensionContextMenuModelTest::CommandState |
| ExtensionContextMenuModelTest::GetPageAccessCommandState( |
| const ExtensionContextMenuModel& menu, |
| int command) const { |
| // Check this method is called only for submenu page access commands. |
| DCHECK(command == kOnClick || command == kOnSite || command == kOnAllSites || |
| command == kLearnMore || command == kPermissionsPage); |
| |
| // Every page access command is absent if there is no page access submenu. |
| if (!HasPageAccessSubmenu(menu)) |
| return CommandState::kAbsent; |
| |
| ui::MenuModel* submenu = menu.GetSubmenuModelAt( |
| menu.GetIndexOfCommandId(ExtensionContextMenuModel::PAGE_ACCESS_SUBMENU) |
| .value()); |
| DCHECK(submenu); |
| |
| ui::MenuModel** menu_to_search = &submenu; |
| size_t index_unused = 0; |
| if (!ui::MenuModel::GetModelAndIndexForCommandId(command, menu_to_search, |
| &index_unused)) { |
| return CommandState::kAbsent; |
| } |
| |
| // The command is present; determine if it's enabled. |
| return menu.IsCommandIdEnabled(command) ? CommandState::kEnabled |
| : CommandState::kDisabled; |
| } |
| |
| bool ExtensionContextMenuModelTest::HasPageAccessSubmenu( |
| const ExtensionContextMenuModel& menu) const { |
| return GetCommandState(menu, |
| ExtensionContextMenuModel::PAGE_ACCESS_SUBMENU) != |
| CommandState::kAbsent; |
| } |
| |
| bool ExtensionContextMenuModelTest::HasCantAccessPageEntry( |
| const ExtensionContextMenuModel& menu) const { |
| CommandState cant_access_state = |
| GetCommandState(menu, ExtensionContextMenuModel::PAGE_ACCESS_CANT_ACCESS); |
| |
| // The "Can't access this page" entry, if present, is always disabled. |
| EXPECT_NE(cant_access_state, CommandState::kEnabled); |
| return cant_access_state == CommandState::kDisabled; |
| } |
| |
| void ExtensionContextMenuModelTest::SetUp() { |
| ExtensionServiceTestBase::SetUp(); |
| scoped_screen_override_ = |
| std::make_unique<ScopedScreenOverride>(&test_screen_); |
| } |
| |
| void ExtensionContextMenuModelTest::TearDown() { |
| // Remove any tabs in the tab strip; else the test crashes. |
| if (browser_) { |
| while (!browser_->tab_strip_model()->empty()) |
| browser_->tab_strip_model()->DetachAndDeleteWebContentsAt(0); |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS_ASH) |
| // The ash::KioskAppManager, if initialized, needs to be cleaned up. |
| // TODO(devlin): This should probably go somewhere more central, like |
| // chromeos::ScopedCrosSettingsTestHelper. |
| ash::KioskAppManager::Shutdown(); |
| #endif |
| |
| ExtensionServiceTestBase::TearDown(); |
| } |
| |
| // Tests that applicable menu items are disabled when a ManagementPolicy |
| // prohibits them. |
| TEST_F(ExtensionContextMenuModelTest, RequiredInstallationsDisablesItems) { |
| InitializeEmptyExtensionService(); |
| |
| // Test that management policy can determine whether or not policy-installed |
| // extensions can be installed/uninstalled. |
| const Extension* extension = |
| AddExtension("extension", manifest_keys::kPageAction, |
| ManifestLocation::kExternalPolicy); |
| |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| ExtensionSystem* system = ExtensionSystem::Get(profile()); |
| system->management_policy()->UnregisterAllProviders(); |
| |
| // Uninstallation should be, by default, enabled. |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::UNINSTALL), |
| CommandState::kEnabled); |
| |
| TestManagementPolicyProvider policy_provider( |
| TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS); |
| system->management_policy()->RegisterProvider(&policy_provider); |
| |
| // If there's a policy provider that requires the extension stay enabled, then |
| // uninstallation should be disabled. |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::UNINSTALL), |
| CommandState::kDisabled); |
| size_t uninstall_index = |
| menu.GetIndexOfCommandId(ExtensionContextMenuModel::UNINSTALL).value(); |
| // There should also be an icon to visually indicate why uninstallation is |
| // forbidden. |
| ui::ImageModel icon = menu.GetIconAt(uninstall_index); |
| EXPECT_FALSE(icon.IsEmpty()); |
| |
| // Don't leave |policy_provider| dangling. |
| system->management_policy()->UnregisterProvider(&policy_provider); |
| } |
| |
| // Tests the context menu for a component extension. |
| TEST_F(ExtensionContextMenuModelTest, ComponentExtensionContextMenu) { |
| InitializeEmptyExtensionService(); |
| |
| std::string name("component"); |
| std::unique_ptr<base::DictionaryValue> manifest = |
| DictionaryBuilder() |
| .Set("name", name) |
| .Set("version", "1") |
| .Set("manifest_version", 2) |
| .Set("browser_action", DictionaryBuilder().Build()) |
| .Build(); |
| |
| { |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder() |
| .SetManifest(base::DictionaryValue::From( |
| base::Value::ToUniquePtrValue(manifest->Clone()))) |
| .SetID(crx_file::id_util::GenerateId("component")) |
| .SetLocation(ManifestLocation::kComponent) |
| .Build(); |
| service()->AddExtension(extension.get()); |
| |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| // A component extension's context menu should not include options for |
| // managing extensions or removing it, and should only include an option for |
| // the options page if the extension has one (which this one doesn't). |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::OPTIONS), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::UNINSTALL), |
| CommandState::kAbsent); |
| EXPECT_EQ( |
| GetCommandState(menu, ExtensionContextMenuModel::MANAGE_EXTENSIONS), |
| CommandState::kAbsent); |
| |
| // The "name" option should be present, but not enabled for component |
| // extensions. |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::HOME_PAGE), |
| CommandState::kDisabled); |
| } |
| |
| { |
| // Check that a component extension with an options page does have the |
| // options menu item, and it is enabled. |
| manifest->SetStringKey("options_page", "options_page.html"); |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder() |
| .SetManifest(std::move(manifest)) |
| .SetID(crx_file::id_util::GenerateId("component_opts")) |
| .SetLocation(ManifestLocation::kComponent) |
| .Build(); |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| service()->AddExtension(extension.get()); |
| EXPECT_TRUE(extensions::OptionsPageInfo::HasOptionsPage(extension.get())); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::OPTIONS), |
| CommandState::kEnabled); |
| } |
| } |
| |
| // Tests that the standard menu items (home page, uninstall, and manage |
| // extensions) are always visible for any context menu source. NOTE: |
| // other menu items visibility is dependent on context, and behavior is checked |
| // in other tests. |
| TEST_F(ExtensionContextMenuModelTest, |
| ExtensionContextMenuStandardItemsAlwaysVisible) { |
| InitializeEmptyExtensionService(); |
| const Extension* extension = AddExtension( |
| "extension", manifest_keys::kPageAction, ManifestLocation::kInternal); |
| |
| std::vector<ContextMenuSource> sources{ContextMenuSource::kToolbarAction, |
| ContextMenuSource::kMenuItem}; |
| |
| for (auto source : sources) { |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, source); |
| EXPECT_NE(GetCommandState(menu, ExtensionContextMenuModel::HOME_PAGE), |
| CommandState::kAbsent); |
| EXPECT_NE(GetCommandState(menu, ExtensionContextMenuModel::UNINSTALL), |
| CommandState::kAbsent); |
| EXPECT_NE( |
| GetCommandState(menu, ExtensionContextMenuModel::MANAGE_EXTENSIONS), |
| CommandState::kAbsent); |
| } |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, |
| ExtensionContextMenuToggleVisibilityEntryVisibility) { |
| InitializeEmptyExtensionService(); |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").Build(); |
| InitializeAndAddExtension(*extension); |
| |
| { |
| // Verify the "toggle visibility" entry is absent if the context menu |
| // source is a menu item. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| /* can_show_icon_in_toolbar=*/true, |
| ContextMenuSource::kMenuItem); |
| EXPECT_FALSE( |
| menu.GetIndexOfCommandId(ExtensionContextMenuModel::TOGGLE_VISIBILITY) |
| .has_value()); |
| EXPECT_EQ( |
| GetCommandState(menu, ExtensionContextMenuModel::TOGGLE_VISIBILITY), |
| CommandState::kAbsent); |
| } |
| |
| { |
| // Verify the "toggle visibility" entry is absent if the context menu |
| // source is a toolbar action and the icon cannot be shown in the toolbar. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| /* can_show_icon_in_toolbar=*/false, |
| ContextMenuSource::kToolbarAction); |
| |
| EXPECT_EQ( |
| GetCommandState(menu, ExtensionContextMenuModel::TOGGLE_VISIBILITY), |
| CommandState::kAbsent); |
| } |
| |
| { |
| // Verify the "toggle visibility" entry is enabled if and only if the |
| // context menu source is a toolbar action and the icon can be shown in the |
| // toolbar. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| /* can_show_icon_in_toolbar=*/true, |
| ContextMenuSource::kToolbarAction); |
| EXPECT_EQ( |
| GetCommandState(menu, ExtensionContextMenuModel::TOGGLE_VISIBILITY), |
| CommandState::kEnabled); |
| } |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, |
| ExtensionContextMenuOptionsEntryVisibility) { |
| InitializeEmptyExtensionService(); |
| |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("Extension") |
| .SetManifestVersion(2) |
| .SetID(crx_file::id_util::GenerateId("extension")) |
| .Build(); |
| service()->AddExtension(extension.get()); |
| |
| { |
| // Verify the "options" entry is absent if the extension doesn't have |
| // an options page. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::OPTIONS), |
| CommandState::kAbsent); |
| } |
| |
| scoped_refptr<const Extension> extension_with_options = |
| ExtensionBuilder("Extension with options page") |
| .SetManifestVersion(2) |
| .SetID(crx_file::id_util::GenerateId("extension_with_options_page")) |
| .SetManifestKey("options_page", "options_page.html") |
| .Build(); |
| service()->AddExtension(extension_with_options.get()); |
| |
| { |
| // Verify the "options" entry is enabled if and only if the |
| // extension has an options page. |
| ExtensionContextMenuModel menu(extension_with_options.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::OPTIONS), |
| CommandState::kEnabled); |
| } |
| } |
| |
| // TODO(emiliapaz): Currently, the test scenarios always have "inspect popup" |
| // hidden since the context menu doesn't have a popup delegate and the developer |
| // mode pref is not set. Add a popup delegate and developer mode pref to |
| // properly test the "inspect popup" entry visibility. |
| TEST_F(ExtensionContextMenuModelTest, |
| ExtensionContextMenuInspectPopupEntryVisibility) { |
| InitializeEmptyExtensionService(); |
| { |
| const Extension* page_action = AddExtension( |
| "page_action", manifest_keys::kPageAction, ManifestLocation::kInternal); |
| ASSERT_TRUE(page_action); |
| ExtensionContextMenuModel menu(page_action, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::INSPECT_POPUP), |
| CommandState::kAbsent); |
| } |
| |
| { |
| const Extension* browser_action = |
| AddExtension("browser_action", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal); |
| ExtensionContextMenuModel menu(browser_action, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::INSPECT_POPUP), |
| CommandState::kAbsent); |
| } |
| |
| { |
| // An extension with no specified action has one synthesized. However, |
| // there will never be a popup to inspect, so we shouldn't add a menu item. |
| const Extension* no_action = |
| AddExtension("no_action", nullptr, ManifestLocation::kInternal); |
| ExtensionContextMenuModel menu(no_action, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, ExtensionContextMenuModel::INSPECT_POPUP), |
| CommandState::kAbsent); |
| } |
| } |
| |
| // Test that the "pin" and "unpin" menu items appear correctly in the extension |
| // context menu with toolbar action source. |
| TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuShowAndHide) { |
| InitializeEmptyExtensionService(); |
| Browser* browser = GetBrowser(); |
| extension_action_test_util::CreateToolbarModelForProfile(profile()); |
| const Extension* page_action = |
| AddExtension("page_action_extension", manifest_keys::kPageAction, |
| ManifestLocation::kInternal); |
| const Extension* browser_action = |
| AddExtension("browser_action_extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal); |
| |
| // For laziness. |
| const ExtensionContextMenuModel::MenuEntries visibility_command = |
| ExtensionContextMenuModel::TOGGLE_VISIBILITY; |
| const std::u16string pin_string = |
| l10n_util::GetStringUTF16(IDS_EXTENSIONS_PIN_TO_TOOLBAR); |
| const std::u16string unpin_string = |
| l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNPIN_FROM_TOOLBAR); |
| |
| { |
| // Even page actions should have a visibility option. |
| ExtensionContextMenuModel menu(page_action, browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_EQ(unpin_string, menu.GetLabelAt(index.value())); |
| } |
| |
| { |
| ExtensionContextMenuModel menu(browser_action, browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_EQ(unpin_string, menu.GetLabelAt(index.value())); |
| |
| // Pin before unpinning. |
| ToolbarActionsModel::Get(profile())->SetActionVisibility( |
| browser_action->id(), true); |
| menu.ExecuteCommand(visibility_command, 0); |
| } |
| |
| { |
| // If the action is unpinned, it should have the "Pin" string. |
| ExtensionContextMenuModel menu(browser_action, browser, |
| ExtensionContextMenuModel::UNPINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_EQ(pin_string, menu.GetLabelAt(index.value())); |
| } |
| |
| { |
| // If the action is transitively visible, as happens when it is showing a |
| // popup, we should use the same "Pin" string. |
| ExtensionContextMenuModel menu( |
| browser_action, browser, |
| ExtensionContextMenuModel::TRANSITIVELY_VISIBLE, nullptr, true, |
| ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_EQ(pin_string, menu.GetLabelAt(index.value())); |
| } |
| } |
| |
| // Test that the "pin" and "unpin" menu items is disabled when the extension is |
| // force-pinned via ExtensionSettings. |
| TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuForcePinned) { |
| InitializeEmptyExtensionService(); |
| Browser* browser = GetBrowser(); |
| extension_action_test_util::CreateToolbarModelForProfile(profile()); |
| const Extension* extension = AddExtension( |
| "extension", manifest_keys::kBrowserAction, ManifestLocation::kInternal); |
| const Extension* force_pinned_extension = |
| AddExtension("force_pinned_extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal); |
| |
| std::string json = base::StringPrintf( |
| R"({ |
| "%s": { |
| "toolbar_pin": "force_pinned" |
| } |
| })", |
| force_pinned_extension->id().c_str()); |
| absl::optional<base::Value> parsed = base::JSONReader::Read(json); |
| policy::PolicyMap map; |
| map.Set("ExtensionSettings", policy::POLICY_LEVEL_MANDATORY, |
| policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_PLATFORM, |
| std::move(parsed), nullptr); |
| policy_provider()->UpdateChromePolicy(map); |
| |
| // For laziness. |
| const ExtensionContextMenuModel::MenuEntries visibility_command = |
| ExtensionContextMenuModel::TOGGLE_VISIBILITY; |
| const std::u16string unpin_string = |
| l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNPIN_FROM_TOOLBAR); |
| const std::u16string force_pinned_string = |
| l10n_util::GetStringUTF16(IDS_EXTENSIONS_PINNED_BY_ADMIN); |
| |
| { |
| // Not force-pinned. |
| ExtensionContextMenuModel menu(extension, browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_TRUE(menu.IsEnabledAt(index.value())); |
| EXPECT_EQ(unpin_string, menu.GetLabelAt(index.value())); |
| } |
| |
| { |
| // Force-pinned. |
| ExtensionContextMenuModel menu(force_pinned_extension, browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| absl::optional<size_t> index = menu.GetIndexOfCommandId(visibility_command); |
| ASSERT_TRUE(index.has_value()); |
| EXPECT_FALSE(menu.IsEnabledAt(index.value())); |
| EXPECT_EQ(force_pinned_string, menu.GetLabelAt(index.value())); |
| } |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, ExtensionContextUninstall) { |
| InitializeEmptyExtensionService(); |
| |
| const Extension* extension = AddExtension( |
| "extension", manifest_keys::kBrowserAction, ManifestLocation::kInternal); |
| const std::string extension_id = extension->id(); |
| ASSERT_TRUE(registry()->enabled_extensions().GetByID(extension_id)); |
| |
| ScopedTestDialogAutoConfirm auto_confirm(ScopedTestDialogAutoConfirm::ACCEPT); |
| TestExtensionRegistryObserver uninstalled_observer(registry()); |
| { |
| // Scope the menu so that it's destroyed during the uninstall process. This |
| // reflects what normally happens (Chrome closes the menu when the uninstall |
| // dialog shows up). |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| menu.ExecuteCommand(ExtensionContextMenuModel::UNINSTALL, 0); |
| } |
| uninstalled_observer.WaitForExtensionUninstalled(); |
| EXPECT_FALSE(registry()->GetExtensionById(extension_id, |
| ExtensionRegistry::EVERYTHING)); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, PageAccess_CustomizeByExtension_Submenu) { |
| base::UserActionTester user_action_tester; |
| constexpr char kOnClickAction[] = |
| "Extensions.ContextMenu.Hosts.OnClickClicked"; |
| constexpr char kOnSiteAction[] = "Extensions.ContextMenu.Hosts.OnSiteClicked"; |
| constexpr char kOnAllSitesAction[] = |
| "Extensions.ContextMenu.Hosts.OnAllSitesClicked"; |
| |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension with all urls, and withhold permission. |
| const Extension* extension = |
| AddExtensionWithHostPermission("extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal, "*://*/*"); |
| ScriptingPermissionsModifier(profile(), extension) |
| .SetWithholdHostPermissions(true); |
| EXPECT_TRUE(registry()->enabled_extensions().Contains(extension->id())); |
| |
| const GURL kActiveUrl("http://www.example.com/"); |
| const GURL kOtherUrl("http://www.google.com/"); |
| |
| // Add a tab to the browser. |
| content::WebContents* web_contents = AddTab(kActiveUrl); |
| |
| ExtensionActionRunner* action_runner = |
| ExtensionActionRunner::GetForWebContents(web_contents); |
| ASSERT_TRUE(action_runner); |
| |
| // Pretend the extension wants to run. |
| int run_count = 0; |
| auto increment_run_count_1 = base::BindOnce(&Increment, &run_count); |
| action_runner->RequestScriptInjectionForTesting( |
| extension, mojom::RunLocation::kDocumentIdle, |
| std::move(increment_run_count_1)); |
| |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| // Since we want to test the page access submenu, verify the site permission |
| // is set to "customize by extension" by default and the page access submenu |
| // is visible. |
| EXPECT_EQ(PermissionsManager::Get(profile())->GetUserSiteSetting( |
| url::Origin::Create(kActiveUrl)), |
| PermissionsManager::UserSiteSetting::kCustomizeByExtension); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), CommandState::kEnabled); |
| |
| // Initial state: The extension should be in "run on click" mode. |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| // Initial state: The extension should have all permissions withheld, so |
| // shouldn't be allowed to run on the active url or another arbitrary url, and |
| // should have withheld permissions. |
| ScriptingPermissionsModifier permissions_modifier(profile(), extension); |
| EXPECT_FALSE(permissions_modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_FALSE(permissions_modifier.HasGrantedHostPermission(kOtherUrl)); |
| const PermissionsData* permissions = extension->permissions_data(); |
| EXPECT_FALSE(permissions->withheld_permissions().IsEmpty()); |
| |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnClickAction)); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnSiteAction)); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnAllSitesAction)); |
| |
| // Change the mode to be "Run on site". |
| menu.ExecuteCommand(kOnSite, 0); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnClickAction)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnSiteAction)); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnAllSitesAction)); |
| |
| // The extension should have access to the active url, but not to another |
| // arbitrary url, and the extension should still have withheld permissions. |
| EXPECT_TRUE(permissions_modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_FALSE(permissions_modifier.HasGrantedHostPermission(kOtherUrl)); |
| EXPECT_FALSE(permissions->withheld_permissions().IsEmpty()); |
| |
| // Since the extension has permission, it should have ran. |
| EXPECT_EQ(1, run_count); |
| EXPECT_FALSE(action_runner->WantsToRun(extension)); |
| |
| // On another url, the mode should still be run on click. |
| content::WebContentsTester* web_contents_tester = |
| content::WebContentsTester::For(web_contents); |
| web_contents_tester->NavigateAndCommit(kOtherUrl); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| // And returning to the first url should return the mode to run on site. |
| web_contents_tester->NavigateAndCommit(kActiveUrl); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| // Request another run. |
| auto increment_run_count_2 = base::BindOnce(&Increment, &run_count); |
| action_runner->RequestScriptInjectionForTesting( |
| extension, mojom::RunLocation::kDocumentIdle, |
| std::move(increment_run_count_2)); |
| |
| // Change the mode to be "Run on all sites". |
| menu.ExecuteCommand(kOnAllSites, 0); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnAllSites)); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kOnClickAction)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnSiteAction)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnAllSitesAction)); |
| |
| // The extension should be able to run on any url, and shouldn't have any |
| // withheld permissions. |
| EXPECT_TRUE(permissions_modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_TRUE(permissions_modifier.HasGrantedHostPermission(kOtherUrl)); |
| EXPECT_TRUE(permissions->withheld_permissions().IsEmpty()); |
| |
| // It should have ran again. |
| EXPECT_EQ(2, run_count); |
| EXPECT_FALSE(action_runner->WantsToRun(extension)); |
| |
| // On another url, the mode should also be run on all sites. |
| web_contents_tester->NavigateAndCommit(kOtherUrl); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| web_contents_tester->NavigateAndCommit(kActiveUrl); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| auto increment_run_count_3 = base::BindOnce(&Increment, &run_count); |
| action_runner->RequestScriptInjectionForTesting( |
| extension, mojom::RunLocation::kDocumentIdle, |
| std::move(increment_run_count_3)); |
| |
| // Change extension to run "on click". Since we are revoking permissions, we |
| // need to automatically accept the reload page bubble. |
| action_runner->accept_bubble_for_testing(true); |
| extensions::PermissionsManagerWaiter waiter( |
| extensions::PermissionsManager::Get(profile())); |
| menu.ExecuteCommand(kOnClick, 0); |
| waiter.WaitForExtensionPermissionsUpdate(); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnClickAction)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnSiteAction)); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kOnAllSitesAction)); |
| |
| // We should return to the initial state - no access. |
| EXPECT_FALSE(permissions_modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_FALSE(permissions_modifier.HasGrantedHostPermission(kOtherUrl)); |
| EXPECT_FALSE(permissions->withheld_permissions().IsEmpty()); |
| |
| // And the extension shouldn't have ran. |
| EXPECT_EQ(2, run_count); |
| EXPECT_TRUE(action_runner->WantsToRun(extension)); |
| |
| // Install an extension requesting a single host. The page access submenu |
| // should still be present. |
| const Extension* single_host_extension = AddExtensionWithHostPermission( |
| "single_host_extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal, "http://www.example.com/*"); |
| ExtensionContextMenuModel single_host_menu( |
| single_host_extension, GetBrowser(), ExtensionContextMenuModel::PINNED, |
| nullptr, true, ContextMenuSource::kToolbarAction); |
| EXPECT_TRUE( |
| single_host_menu |
| .GetIndexOfCommandId(ExtensionContextMenuModel::PAGE_ACCESS_SUBMENU) |
| .has_value()); |
| } |
| |
| // Tests different permission patterns when the site setting is set to |
| // "customize by extension". |
| TEST_F(ExtensionContextMenuModelTest, |
| PageAccess_CustomizeByExtension_PermissionPatterns) { |
| InitializeEmptyExtensionService(); |
| |
| struct { |
| // The pattern requested by the extension. |
| std::string requested_pattern; |
| // The pattern that's granted to the extension, if any. This may be |
| // significantly different than the requested pattern. |
| absl::optional<std::string> granted_pattern; |
| // The current URL the context menu will be used on. |
| GURL current_url; |
| // The set of page access menu entries that should be present. |
| std::set<MenuEntries> expected_entries; |
| // The set of page access menu entries that should be enabled. |
| std::set<MenuEntries> enabled_entries; |
| // The selected page access menu entry. |
| absl::optional<MenuEntries> selected_entry; |
| } test_cases[] = { |
| // Easy cases: site the extension wants to run on, with or without |
| // permission granted. |
| {"https://google.com/maps", |
| "https://google.com/maps", |
| GURL("https://google.com/maps"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnSite}, |
| {"https://google.com/maps", |
| absl::nullopt, |
| GURL("https://google.com/maps"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnClick}, |
| // We should display the page access controls if the extension wants to |
| // run on the specified origin, even if not on the exact site itself. |
| {"https://google.com/maps", |
| "https://google.com/maps", |
| GURL("https://google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnSite}, |
| // The menu should be hidden if the extension cannot run on the origin. |
| {"https://google.com/maps", |
| "https://google.com/maps", |
| GURL("https://mail.google.com"), |
| {}, |
| {}}, |
| // An extension with all hosts granted should display the all sites |
| // controls, even if it didn't request all sites. |
| {"https://google.com/maps", |
| "*://*/*", |
| GURL("https://mail.google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| // Subdomain pattern tests. |
| {"https://*.google.com/*", |
| "https://*.google.com/*", |
| GURL("https://google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnSite}, |
| {"https://*.google.com/*", |
| absl::nullopt, |
| GURL("https://google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnClick}, |
| {"https://*.google.com/*", |
| "https://*.google.com/*", |
| GURL("https://mail.google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnSite}, |
| {"https://*.google.com/*", |
| "https://google.com/*", |
| GURL("https://mail.google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnClick}, |
| // On sites the extension doesn't want to run on, no controls should be |
| // shown... |
| {"https://*.google.com/*", |
| absl::nullopt, |
| GURL("https://example.com"), |
| {}}, |
| // ...unless the extension has access to the page, in which case we should |
| // display the controls. |
| {"https://*.google.com/*", |
| "https://*.example.com/*", |
| GURL("https://example.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite}, |
| kOnSite}, |
| // All-hosts like permissions should be treated as if the extension |
| // requested access to all urls. |
| {"https://*/maps", |
| "https://*/maps", |
| GURL("https://google.com/maps"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| {"https://*/maps", |
| "https://google.com/*", |
| GURL("https://google.com/maps"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnSite}, |
| {"https://*/maps", |
| "https://*/maps", |
| GURL("https://google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| {"https://*/maps", |
| "https://*/maps", |
| GURL("https://chromium.org"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| {"https://*.com/*", |
| "https://*.com/*", |
| GURL("https://google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| {"https://*.com/*", |
| "https://*.com/*", |
| GURL("https://maps.google.com"), |
| {kOnClick, kOnSite, kOnAllSites}, |
| {kOnClick, kOnSite, kOnAllSites}, |
| kOnAllSites}, |
| // Even with an all-hosts like pattern, we shouldn't show access controls |
| // if the extension can't run on the origin (though we show the learn more |
| // option). |
| {"https://*.com/*", |
| "https://*.com/*", |
| GURL("https://chromium.org"), |
| {}, |
| {}}, |
| // No access controls should ever show for restricted pages, like |
| // chrome:-scheme pages or the webstore. |
| {"<all_urls>", "<all_urls>", GURL("chrome://extensions"), {}, {}}, |
| {"<all_urls>", |
| "<all_urls>", |
| ExtensionsClient::Get()->GetWebstoreBaseURL(), |
| {}, |
| {}}, |
| }; |
| |
| // Add a web contents to the browser. |
| content::WebContents* web_contents = AddTab(GURL("about:blank")); |
| content::WebContentsTester* web_contents_tester = |
| content::WebContentsTester::For(web_contents); |
| |
| for (const auto& test_case : test_cases) { |
| SCOPED_TRACE(base::StringPrintf( |
| "Request: '%s'; Granted: %s; URL: %s", |
| test_case.requested_pattern.c_str(), |
| test_case.granted_pattern.value_or(std::string()).c_str(), |
| test_case.current_url.spec().c_str())); |
| |
| // Install an extension with the specified permission. |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("test") |
| .AddContentScript("script.js", {test_case.requested_pattern}) |
| .Build(); |
| InitializeAndAddExtension(*extension); |
| |
| ScriptingPermissionsModifier(profile(), extension) |
| .SetWithholdHostPermissions(true); |
| if (test_case.granted_pattern) { |
| URLPattern pattern(UserScript::ValidUserScriptSchemes(false), |
| *test_case.granted_pattern); |
| permissions_test_util::GrantRuntimePermissionsAndWaitForCompletion( |
| profile(), *extension, |
| PermissionSet(APIPermissionSet(), ManifestPermissionSet(), |
| URLPatternSet(), URLPatternSet({pattern}))); |
| } |
| |
| web_contents_tester->NavigateAndCommit(test_case.current_url); |
| |
| // Site permission should be set to "customize by extension" by default. |
| EXPECT_EQ(PermissionsManager::Get(profile())->GetUserSiteSetting( |
| url::Origin::Create(test_case.current_url)), |
| PermissionsManager::UserSiteSetting::kCustomizeByExtension); |
| |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| EXPECT_EQ(test_case.selected_entry.has_value(), |
| !test_case.expected_entries.empty()) |
| << "If any entries are available, one should be selected."; |
| |
| if (test_case.expected_entries.empty()) { |
| // If there are no expected entries (i.e., the extension can't run on the |
| // page), there should be no submenu and instead there should be a |
| // disabled label. |
| EXPECT_TRUE(HasCantAccessPageEntry(menu)); |
| EXPECT_FALSE(HasPageAccessSubmenu(menu)); |
| continue; |
| } |
| |
| // The learn more option should be visible whenever the page access submenu |
| // is. |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kLearnMore)); |
| |
| auto get_expected_state = [test_case](MenuEntries command) { |
| if (!test_case.expected_entries.count(command)) |
| return CommandState::kAbsent; |
| return test_case.enabled_entries.count(command) ? CommandState::kEnabled |
| : CommandState::kDisabled; |
| }; |
| |
| // Verify the submenu options are what we expect. |
| EXPECT_EQ(get_expected_state(kOnClick), |
| GetPageAccessCommandState(menu, kOnClick)); |
| EXPECT_EQ(get_expected_state(kOnSite), |
| GetPageAccessCommandState(menu, kOnSite)); |
| EXPECT_EQ(get_expected_state(kOnAllSites), |
| GetPageAccessCommandState(menu, kOnAllSites)); |
| |
| auto should_command_be_checked = [test_case](int command) { |
| return test_case.selected_entry && *test_case.selected_entry == command; |
| }; |
| |
| if (test_case.expected_entries.count(kOnClick)) { |
| EXPECT_EQ(should_command_be_checked(kOnClick), |
| menu.IsCommandIdChecked(kOnClick)); |
| } |
| if (test_case.expected_entries.count(kOnSite)) { |
| EXPECT_EQ(should_command_be_checked(kOnSite), |
| menu.IsCommandIdChecked(kOnSite)); |
| } |
| if (test_case.expected_entries.count(kOnAllSites)) { |
| EXPECT_EQ(should_command_be_checked(kOnAllSites), |
| menu.IsCommandIdChecked(kOnAllSites)); |
| } |
| |
| // Uninstall the extension so as not to conflict with more additions. |
| std::u16string error; |
| EXPECT_TRUE(service()->UninstallExtension( |
| extension->id(), UNINSTALL_REASON_FOR_TESTING, &error)); |
| EXPECT_TRUE(error.empty()) << error; |
| EXPECT_EQ(nullptr, registry()->GetInstalledExtension(extension->id())); |
| } |
| } |
| |
| // Test that changing to 'run on site' while already having an all_url like |
| // pattern actually removes the broad pattern to restrict to the site. |
| TEST_F(ExtensionContextMenuModelTest, |
| PageAccess_CustomizeByExtension_OnSiteWithAllURLs) { |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension with all urls, and withhold permissions. |
| const Extension* extension = |
| AddExtensionWithHostPermission("extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal, "<all_urls>"); |
| ScriptingPermissionsModifier(profile(), extension) |
| .SetWithholdHostPermissions(true); |
| |
| // Grant the extension the all_urls pattern. |
| URLPattern pattern(UserScript::ValidUserScriptSchemes(false), "<all_urls>"); |
| permissions_test_util::GrantRuntimePermissionsAndWaitForCompletion( |
| profile(), *extension, |
| PermissionSet(APIPermissionSet(), ManifestPermissionSet(), |
| URLPatternSet({pattern}), URLPatternSet())); |
| ScriptingPermissionsModifier modifier(profile(), extension); |
| EXPECT_TRUE(modifier.HasWithheldHostPermissions()); |
| |
| const GURL kActiveUrl("http://www.example.com/"); |
| const GURL kOtherUrl("http://www.google.com/"); |
| |
| // Navigate to a url that should have "customize by extension" site |
| // permissions by default (which allows us to test the page access submenu). |
| AddTab(kActiveUrl); |
| EXPECT_EQ(PermissionsManager::Get(profile())->GetUserSiteSetting( |
| url::Origin::Create(kActiveUrl)), |
| PermissionsManager::UserSiteSetting::kCustomizeByExtension); |
| |
| // Verify the extension can run on all sites for the active url, and has |
| // access to both urls. |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_TRUE(HasPageAccessSubmenu(menu)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kOtherUrl)); |
| |
| // Change mode to "Run on site". |
| menu.ExecuteCommand(kOnSite, 0); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| // The extension should have access to the active url, but not to another |
| // arbitrary url. |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_FALSE(modifier.HasGrantedHostPermission(kOtherUrl)); |
| } |
| |
| // Test that changing to 'run on click' while having a broad pattern which |
| // doesn't actually overlap the current url, still actually removes that broad |
| // pattern and stops showing that the extension can run on all sites. |
| // TODO(tjudkins): This test is kind of bizarre in that it highlights a case |
| // where the submenu is displaying that extension can read data on all sites, |
| // when it can't actually read the site it is currently on. We should revisit |
| // what exactly the submenu should be conveying to the user about the current |
| // page and how that relates to the similar set of information on the Extension |
| // Settings page. |
| TEST_F(ExtensionContextMenuModelTest, |
| PageAccess_Customize_ByExtension_OnClickWithBroadPattern) { |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension with all urls, and withhold permissions. |
| const Extension* extension = |
| AddExtensionWithHostPermission("extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal, "<all_urls>"); |
| ScriptingPermissionsModifier modifier(profile(), extension); |
| modifier.SetWithholdHostPermissions(true); |
| |
| // Grant the extension a broad pattern which doesn't overlap the active url. |
| URLPattern pattern(UserScript::ValidUserScriptSchemes(false), "*://*.org/*"); |
| permissions_test_util::GrantRuntimePermissionsAndWaitForCompletion( |
| profile(), *extension, |
| PermissionSet(APIPermissionSet(), ManifestPermissionSet(), |
| URLPatternSet({pattern}), URLPatternSet())); |
| |
| const GURL kActiveUrl("http://www.example.com/"); |
| const GURL kOrgUrl("http://chromium.org/"); |
| const GURL kOtherUrl("http://www.google.com/"); |
| |
| // Also explicitly grant google.com. |
| modifier.GrantHostPermission(kOtherUrl); |
| EXPECT_TRUE(modifier.HasWithheldHostPermissions()); |
| |
| // Navigate to a url that should have "customize by extension" site |
| // permissions by default (which allows us to test the page access submenu). |
| content::WebContents* web_contents = AddTab(kActiveUrl); |
| EXPECT_EQ(PermissionsManager::Get(profile())->GetUserSiteSetting( |
| url::Origin::Create(kActiveUrl)), |
| PermissionsManager::UserSiteSetting::kCustomizeByExtension); |
| |
| // Verify the extension can run on all sites even though it |
| // can't access the active url. |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_TRUE(HasPageAccessSubmenu(menu)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| EXPECT_FALSE(modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kOrgUrl)); |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kOtherUrl)); |
| |
| // Change extension to run "on click". Since we are revoking permissions, we |
| // need to automatically accept the reload page bubble. |
| ExtensionActionRunner::GetForWebContents(web_contents) |
| ->accept_bubble_for_testing(true); |
| extensions::PermissionsManagerWaiter waiter( |
| extensions::PermissionsManager::Get(profile())); |
| menu.ExecuteCommand(kOnClick, 0); |
| waiter.WaitForExtensionPermissionsUpdate(); |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| |
| // The broad org pattern should have been removed, but the explicit google |
| // pattern should still remain. |
| EXPECT_FALSE(modifier.HasGrantedHostPermission(kActiveUrl)); |
| EXPECT_FALSE(modifier.HasGrantedHostPermission(kOrgUrl)); |
| EXPECT_TRUE(modifier.HasGrantedHostPermission(kOtherUrl)); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, |
| PageAccess_CustomizeByExtension_WithActiveTab) { |
| InitializeEmptyExtensionService(); |
| |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").AddPermissions({"activeTab"}).Build(); |
| InitializeAndAddExtension(*extension); |
| |
| // Navigate to a url that should have "customize by extension" site |
| // permissions by default (which allows us to test the page access submenu). |
| const GURL url("https://a.com"); |
| AddTab(url); |
| EXPECT_EQ(PermissionsManager::Get(profile())->GetUserSiteSetting( |
| url::Origin::Create(url)), |
| PermissionsManager::UserSiteSetting::kCustomizeByExtension); |
| |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_TRUE(HasPageAccessSubmenu(menu)); |
| EXPECT_EQ(CommandState::kEnabled, GetPageAccessCommandState(menu, kOnClick)); |
| EXPECT_EQ(CommandState::kDisabled, GetPageAccessCommandState(menu, kOnSite)); |
| EXPECT_EQ(CommandState::kDisabled, |
| GetPageAccessCommandState(menu, kOnAllSites)); |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kLearnMore)); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, |
| TestTogglingAccessWithSpecificSitesWithUnrequestedUrl) { |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension that wants access to a.com. |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").AddPermission("*://a.com/*").Build(); |
| InitializeAndAddExtension(*extension); |
| |
| // Additionally, grant it the (unrequested) access to b.com. |
| ExtensionPrefs* prefs = ExtensionPrefs::Get(profile()); |
| URLPattern b_com_pattern(Extension::kValidHostPermissionSchemes, |
| "*://b.com/*"); |
| PermissionSet b_com_permissions(APIPermissionSet(), ManifestPermissionSet(), |
| URLPatternSet({b_com_pattern}), |
| URLPatternSet()); |
| prefs->AddGrantedPermissions(extension->id(), b_com_permissions); |
| |
| ScriptingPermissionsModifier modifier(profile(), extension); |
| EXPECT_FALSE(modifier.HasWithheldHostPermissions()); |
| |
| const GURL a_com("https://a.com"); |
| content::WebContents* web_contents = AddTab(a_com); |
| |
| { |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| // Without withholding host permissions, the menu should be visible on |
| // a.com... |
| EXPECT_TRUE(HasPageAccessSubmenu(menu)); |
| EXPECT_FALSE(HasCantAccessPageEntry(menu)); |
| |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kOnClick)); |
| EXPECT_EQ(CommandState::kEnabled, GetPageAccessCommandState(menu, kOnSite)); |
| EXPECT_EQ(CommandState::kDisabled, |
| GetPageAccessCommandState(menu, kOnAllSites)); |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kLearnMore)); |
| |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnAllSites)); |
| } |
| |
| const GURL b_com("https://b.com"); |
| content::WebContentsTester* web_contents_tester = |
| content::WebContentsTester::For(web_contents); |
| web_contents_tester->NavigateAndCommit(b_com); |
| |
| { |
| // ... but not on b.com, where it doesn't want to run. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_FALSE(HasPageAccessSubmenu(menu)); |
| EXPECT_TRUE(HasCantAccessPageEntry(menu)); |
| } |
| |
| modifier.SetWithholdHostPermissions(true); |
| |
| // However, if the extension has runtime-granted permissions to b.com, we |
| // *should* display them in the menu. |
| permissions_test_util::GrantRuntimePermissionsAndWaitForCompletion( |
| profile(), *extension, b_com_permissions); |
| |
| { |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_TRUE(HasPageAccessSubmenu(menu)); |
| EXPECT_FALSE(HasCantAccessPageEntry(menu)); |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kOnClick)); |
| EXPECT_EQ(CommandState::kEnabled, GetPageAccessCommandState(menu, kOnSite)); |
| EXPECT_EQ(CommandState::kDisabled, |
| GetPageAccessCommandState(menu, kOnAllSites)); |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kLearnMore)); |
| |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| |
| // Set the extension to run "on click". Since we are revoking b.com |
| // permissions, we need to automatically accept the reload page bubble. |
| menu.ExecuteCommand(kOnClick, 0); |
| ExtensionActionRunner::GetForWebContents(web_contents) |
| ->accept_bubble_for_testing(true); |
| extensions::PermissionsManagerWaiter waiter( |
| extensions::PermissionsManager::Get(profile())); |
| menu.ExecuteCommand(kOnClick, 0); |
| waiter.WaitForExtensionPermissionsUpdate(); |
| } |
| |
| { |
| PermissionsManager::ExtensionSiteAccess site_access = |
| PermissionsManager::Get(profile())->GetSiteAccess(*extension, b_com); |
| EXPECT_FALSE(site_access.has_site_access); |
| EXPECT_FALSE(site_access.withheld_site_access); |
| } |
| |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| // Somewhat strangely, this also removes the access controls, because we don't |
| // show it for sites the extension doesn't want to run on. |
| EXPECT_FALSE(HasPageAccessSubmenu(menu)); |
| EXPECT_TRUE(HasCantAccessPageEntry(menu)); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, |
| TestTogglingAccessWithSpecificSitesWithRequestedSites) { |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension that wants access to a.com and b.com. |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension") |
| .AddPermissions({"*://a.com/*", "*://b.com/*"}) |
| .Build(); |
| InitializeAndAddExtension(*extension); |
| |
| ScriptingPermissionsModifier modifier(profile(), extension); |
| EXPECT_FALSE(modifier.HasWithheldHostPermissions()); |
| |
| const GURL a_com("https://a.com"); |
| content::WebContents* web_contents = AddTab(a_com); |
| |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| EXPECT_EQ(CommandState::kEnabled, GetPageAccessCommandState(menu, kOnClick)); |
| EXPECT_EQ(CommandState::kEnabled, GetPageAccessCommandState(menu, kOnSite)); |
| EXPECT_EQ(CommandState::kDisabled, |
| GetPageAccessCommandState(menu, kOnAllSites)); |
| |
| EXPECT_TRUE(menu.IsCommandIdChecked(kOnSite)); |
| EXPECT_FALSE(menu.IsCommandIdChecked(kOnClick)); |
| |
| // Withhold access on a.com by setting the extension to run "on click". Since |
| // we are revoking permissions, we need to automatically accept the reload |
| // page bubble. |
| ExtensionActionRunner::GetForWebContents(web_contents) |
| ->accept_bubble_for_testing(true); |
| extensions::PermissionsManagerWaiter waiter( |
| extensions::PermissionsManager::Get(profile())); |
| menu.ExecuteCommand(kOnClick, 0); |
| waiter.WaitForExtensionPermissionsUpdate(); |
| |
| // This, sadly, removes access for the extension on b.com as well. :( This |
| // is because we revoke all host permissions when transitioning from "don't |
| // withhold" to "do withhold". |
| // TODO(devlin): We should fix that, so that toggling access on a.com doesn't |
| // revoke access on b.com. |
| const GURL b_com("https://b.com"); |
| PermissionsManager::ExtensionSiteAccess site_access = |
| PermissionsManager::Get(profile())->GetSiteAccess(*extension, b_com); |
| EXPECT_FALSE(site_access.has_site_access); |
| EXPECT_TRUE(site_access.withheld_site_access); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, TestClickingPageAccessLearnMore) { |
| base::UserActionTester user_action_tester; |
| constexpr char kLearnMoreAction[] = |
| "Extensions.ContextMenu.Hosts.LearnMoreClicked"; |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension that wants access to a.com. |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").AddPermission("*://a.com/*").Build(); |
| InitializeAndAddExtension(*extension); |
| |
| ScriptingPermissionsModifier modifier(profile(), extension); |
| EXPECT_FALSE(modifier.HasWithheldHostPermissions()); |
| |
| const GURL a_com("https://a.com"); |
| AddTab(a_com); |
| |
| Browser* browser = GetBrowser(); |
| ExtensionContextMenuModel menu(extension.get(), browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(0, user_action_tester.GetActionCount(kLearnMoreAction)); |
| |
| EXPECT_EQ(CommandState::kEnabled, |
| GetPageAccessCommandState(menu, kLearnMore)); |
| menu.ExecuteCommand(kLearnMore, 0); |
| |
| EXPECT_EQ(2, browser->tab_strip_model()->count()); |
| content::WebContents* web_contents = |
| browser->tab_strip_model()->GetActiveWebContents(); |
| EXPECT_EQ(1, user_action_tester.GetActionCount(kLearnMoreAction)); |
| |
| // Test web contents need a poke to commit. |
| content::NavigationController& controller = web_contents->GetController(); |
| content::RenderFrameHostTester::CommitPendingLoad(&controller); |
| |
| EXPECT_EQ(GURL(chrome_extension_constants::kRuntimeHostPermissionsHelpURL), |
| web_contents->GetLastCommittedURL()); |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, HistogramTest_Basic) { |
| InitializeEmptyExtensionService(); |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").Build(); |
| InitializeAndAddExtension(*extension); |
| constexpr char kHistogramName[] = "Extensions.ContextMenuAction"; |
| { |
| base::HistogramTester tester; |
| { |
| // The menu is constructed, but never shown. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| } |
| tester.ExpectTotalCount(kHistogramName, 0); |
| } |
| |
| { |
| base::HistogramTester tester; |
| { |
| // The menu is constructed and shown, but no action is taken. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| menu.OnMenuWillShow(&menu); |
| menu.MenuClosed(&menu); |
| } |
| tester.ExpectUniqueSample( |
| kHistogramName, ExtensionContextMenuModel::ContextMenuAction::kNoAction, |
| 1 /* expected_count */); |
| } |
| |
| { |
| base::HistogramTester tester; |
| { |
| // The menu is constructed, shown, and an action taken. |
| ExtensionContextMenuModel menu(extension.get(), GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| menu.OnMenuWillShow(&menu); |
| menu.ExecuteCommand(ExtensionContextMenuModel::MANAGE_EXTENSIONS, 0); |
| menu.MenuClosed(&menu); |
| } |
| |
| tester.ExpectUniqueSample( |
| kHistogramName, |
| ExtensionContextMenuModel::ContextMenuAction::kManageExtensions, |
| 1 /* expected_count */); |
| } |
| } |
| |
| TEST_F(ExtensionContextMenuModelTest, HistogramTest_CustomCommand) { |
| constexpr char kHistogramName[] = "Extensions.ContextMenuAction"; |
| |
| InitializeEmptyExtensionService(); |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").SetAction(ActionInfo::TYPE_BROWSER).Build(); |
| InitializeAndAddExtension(*extension); |
| |
| MenuManager* const manager = CreateMenuManager(); |
| ASSERT_TRUE(manager); |
| |
| MenuBuilder builder(extension, GetBrowser(), manager); |
| builder.AddContextItem(MenuItem::BROWSER_ACTION); |
| std::unique_ptr<ExtensionContextMenuModel> menu = builder.BuildMenu(); |
| EXPECT_EQ(1, CountExtensionItems(*menu)); |
| |
| base::HistogramTester tester; |
| menu->OnMenuWillShow(menu.get()); |
| menu->ExecuteCommand( |
| ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0), 0); |
| menu->MenuClosed(menu.get()); |
| |
| tester.ExpectUniqueSample( |
| kHistogramName, |
| ExtensionContextMenuModel::ContextMenuAction::kCustomCommand, |
| 1 /* expected_count */); |
| } |
| |
| class ExtensionActionContextMenuModelTest |
| : public ExtensionContextMenuModelTest, |
| public testing::WithParamInterface<ActionInfo::Type> {}; |
| |
| TEST_P(ExtensionActionContextMenuModelTest, |
| MenuItemShowsOnlyForAppropriateActionType) { |
| const ActionInfo::Type action_type = GetParam(); |
| |
| InitializeEmptyExtensionService(); |
| |
| scoped_refptr<const Extension> extension = |
| BuildExtensionWithActionType(action_type); |
| service()->AddExtension(extension.get()); |
| |
| MenuManager* const manager = CreateMenuManager(); |
| |
| std::set<ActionInfo::Type> mismatched_types = { |
| ActionInfo::TYPE_PAGE, ActionInfo::TYPE_BROWSER, ActionInfo::TYPE_ACTION}; |
| mismatched_types.erase(GetParam()); |
| |
| // Currently, there are no associated context menu items. |
| MenuBuilder builder(extension, GetBrowser(), manager); |
| EXPECT_EQ(0, CountExtensionItems(*builder.BuildMenu())); |
| |
| for (ActionInfo::Type type : mismatched_types) { |
| builder.AddContextItem(MenuItemContextForActionType(type)); |
| // Adding a menu item for an invalid type shouldn't result in a visible |
| // menu item. |
| EXPECT_EQ(0, CountExtensionItems(*builder.BuildMenu())); |
| } |
| |
| builder.AddContextItem(MenuItemContextForActionType(action_type)); |
| EXPECT_EQ(1, CountExtensionItems(*builder.BuildMenu())); |
| } |
| |
| TEST_P(ExtensionActionContextMenuModelTest, ActionMenuItemsAreLimited) { |
| const ActionInfo::Type action_type = GetParam(); |
| InitializeEmptyExtensionService(); |
| |
| scoped_refptr<const Extension> extension = |
| BuildExtensionWithActionType(action_type); |
| service()->AddExtension(extension.get()); |
| |
| MenuManager* const manager = CreateMenuManager(); |
| |
| MenuBuilder builder(extension, GetBrowser(), manager); |
| EXPECT_EQ(0, CountExtensionItems(*builder.BuildMenu())); |
| |
| const MenuItem::Context context_type = |
| MenuItemContextForActionType(action_type); |
| for (int i = 0; i < api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT + 1; ++i) |
| builder.AddContextItem(context_type); |
| |
| // Even though LIMIT + 1 items were added, only LIMIT should be displayed. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*builder.BuildMenu())); |
| } |
| |
| // Tests that top-level items adjust according to the visibility of others |
| // in the list. |
| TEST_P(ExtensionActionContextMenuModelTest, |
| ActionItemsOverTheLimitAreShownIfSomeOthersAreHidden) { |
| // This test uses hard-coded assumptions about the value of the top-level |
| // limit in order to aid in readability. Assert that the value is expected. |
| // Note: This can't be a static_assert() because the LIMIT is defined in a |
| // different object file. |
| ASSERT_EQ(6, api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT); |
| const ActionInfo::Type action_type = GetParam(); |
| InitializeEmptyExtensionService(); |
| |
| scoped_refptr<const Extension> extension = |
| BuildExtensionWithActionType(action_type); |
| service()->AddExtension(extension.get()); |
| |
| MenuManager* const manager = CreateMenuManager(); |
| |
| MenuBuilder builder(extension, GetBrowser(), manager); |
| EXPECT_EQ(0, CountExtensionItems(*builder.BuildMenu())); |
| |
| const MenuItem::Context context_type = |
| MenuItemContextForActionType(action_type); |
| constexpr int kNumItemsToAdd = 9; // 3 over the limit. |
| |
| // Note: One-indexed; add exactly kNumItemsToAdd (9) items. |
| for (int i = 1; i <= kNumItemsToAdd; ++i) { |
| builder.AddContextItem(context_type); |
| builder.SetItemTitle(i, |
| base::StringPrintf("%s%d", item_label().c_str(), i)); |
| } |
| |
| // We should cap the visible actions. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*builder.BuildMenu())); |
| |
| // By default, the additional action items have their visibility set to true. |
| // Explicitly hide the eighth. |
| builder.SetItemVisibility(8, false); |
| |
| { |
| auto model = builder.BuildMenu(); |
| |
| // The limit is still obeyed, so items 7 through 9 should not be visible. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*model)); |
| VerifyItems(*model, {"1", "2", "3", "4", "5", "6"}); |
| } |
| |
| // Hide the first two items. |
| builder.SetItemVisibility(1, false); |
| builder.SetItemVisibility(2, false); |
| |
| { |
| auto model = builder.BuildMenu(); |
| // Hiding the first two items in the model should make visible the "extra" |
| // items -- items 7 and 9. Note, item 8 was set to hidden, so it should not |
| // show in the model. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*model)); |
| VerifyItems(*model, {"3", "4", "5", "6", "7", "9"}); |
| } |
| |
| // Unhide the eighth item. |
| builder.SetItemVisibility(8, true); |
| |
| { |
| auto model = builder.BuildMenu(); |
| // The ninth item should be replaced with the eighth. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*model)); |
| VerifyItems(*model, {"3", "4", "5", "6", "7", "8"}); |
| } |
| |
| // Unhide the first two items. |
| builder.SetItemVisibility(1, true); |
| builder.SetItemVisibility(2, true); |
| |
| { |
| auto model = builder.BuildMenu(); |
| // Unhiding the first two items should put us back into the original state, |
| // with only the first items displayed. |
| EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, |
| CountExtensionItems(*model)); |
| VerifyItems(*model, {"1", "2", "3", "4", "5", "6"}); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| ExtensionActionContextMenuModelTest, |
| testing::Values(ActionInfo::TYPE_PAGE, |
| ActionInfo::TYPE_BROWSER, |
| ActionInfo::TYPE_ACTION)); |
| |
| class ExtensionContextMenuModelWithUserHostControlsTest |
| : public ExtensionContextMenuModelTest, |
| public testing::WithParamInterface<bool> { |
| public: |
| ExtensionContextMenuModelWithUserHostControlsTest() { |
| const base::Feature& feature = |
| extensions_features::kExtensionsMenuAccessControl; |
| if (GetParam()) |
| feature_list_.InitAndEnableFeature(feature); |
| else |
| feature_list_.InitAndDisableFeature(feature); |
| } |
| ~ExtensionContextMenuModelWithUserHostControlsTest() override = default; |
| |
| private: |
| base::test::ScopedFeatureList feature_list_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| ExtensionContextMenuModelWithUserHostControlsTest, |
| testing::Bool()); |
| |
| TEST_P(ExtensionContextMenuModelWithUserHostControlsTest, |
| PageAccessItemsVisibilityBasedOnSiteSettings) { |
| InitializeEmptyExtensionService(); |
| |
| const Extension* extension = |
| AddExtensionWithHostPermission("extension", manifest_keys::kBrowserAction, |
| ManifestLocation::kInternal, "<all_urls>"); |
| |
| // Add a tab to the browser. |
| const GURL url("http://www.example.com/"); |
| AddTab(url); |
| |
| { |
| // By default, the site permission is set to "customize by extension". |
| // Verify page access submenu is visible and enabled, and the "learn more" |
| // item is in in the submenu. |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(GetCommandState(menu, kGrantAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kBlockAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetCommandState(menu, kLearnMore), CommandState::kAbsent); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kEnabled); |
| // The "permissions page" item is in the submenu only if the feature is |
| // enabled. |
| EXPECT_EQ(GetCommandState(menu, kPermissionsPage), CommandState::kAbsent); |
| CommandState permission_page_state = |
| GetParam() ? CommandState::kEnabled : CommandState::kAbsent; |
| EXPECT_EQ(GetPageAccessCommandState(menu, kPermissionsPage), |
| permission_page_state); |
| } |
| |
| // User site settings are only taken into account for site access computations |
| // when the feature is enabled, even if they are added by the manager. |
| // Therefore, the context menu should not take into account user site settings |
| // when the feature is disabled. |
| auto* manager = extensions::PermissionsManager::Get(profile()); |
| |
| { |
| // Add site as a user permitted site. |
| extensions::PermissionsManagerWaiter manager_waiter(manager); |
| manager->AddUserPermittedSite(url::Origin::Create(url)); |
| manager_waiter.WaitForUserPermissionsSettingsChange(); |
| |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| if (GetParam()) { |
| // Verify "grant all extensions" item is visible and disabled, and the |
| // "learn more" and "permissions page" item are in the context menu. |
| EXPECT_EQ(GetCommandState(menu, kGrantAllExtensions), |
| CommandState::kDisabled); |
| EXPECT_EQ(GetCommandState(menu, kBlockAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kLearnMore), CommandState::kEnabled); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPermissionsPage), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kAbsent); |
| } else { |
| // Even though we added a site as a user permitted site, the site |
| // permission behaves as "customize by extension". Verify page access |
| // submenu is visible and enabled, the "learn more" item is in in the |
| // submenu and the "permissions page" item is nowhere visible. |
| EXPECT_EQ(GetCommandState(menu, kGrantAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kBlockAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetCommandState(menu, kLearnMore), CommandState::kAbsent); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetCommandState(menu, kPermissionsPage), CommandState::kAbsent); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kPermissionsPage), |
| CommandState::kAbsent); |
| } |
| } |
| |
| { |
| // Add site as a user restricted site. Note that adding a site as restricted |
| // site removes it from the permitted sites. |
| extensions::PermissionsManagerWaiter manager_waiter(manager); |
| manager->AddUserRestrictedSite(url::Origin::Create(url)); |
| manager_waiter.WaitForUserPermissionsSettingsChange(); |
| |
| ExtensionContextMenuModel menu(extension, GetBrowser(), |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| |
| if (GetParam()) { |
| // Verify "block all extensions" item is |
| // visible and disabled, and the "learn more" and "permissions page" item |
| // are in the context menu. |
| EXPECT_EQ(GetCommandState(menu, kGrantAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kBlockAllExtensions), |
| CommandState::kDisabled); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kLearnMore), CommandState::kEnabled); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPermissionsPage), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kAbsent); |
| } else { |
| // Even though we added a site as a user restricted site, the site |
| // permission behaves as "customize by extension". Verify page access |
| // submenu is visible and enabled, the "learn more" item is in in the |
| // submenu and the "permissions page" item is nowhere visible. |
| EXPECT_EQ(GetCommandState(menu, kGrantAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kBlockAllExtensions), |
| CommandState::kAbsent); |
| EXPECT_EQ(GetCommandState(menu, kPageAccessSubmenu), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetCommandState(menu, kLearnMore), CommandState::kAbsent); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kLearnMore), |
| CommandState::kEnabled); |
| EXPECT_EQ(GetCommandState(menu, kPermissionsPage), CommandState::kAbsent); |
| EXPECT_EQ(GetPageAccessCommandState(menu, kPermissionsPage), |
| CommandState::kAbsent); |
| } |
| } |
| } |
| |
| // Test clicking on the "permissions page" item opens the correct link. |
| TEST_P(ExtensionContextMenuModelWithUserHostControlsTest, |
| TestClickingPageAccessPermissionsPage) { |
| base::UserActionTester user_action_tester; |
| constexpr char kPermissionsPageAction[] = |
| "Extensions.ContextMenu.Hosts.PermissionsPageClicked"; |
| InitializeEmptyExtensionService(); |
| |
| // Add an extension that wants access to a.com. |
| scoped_refptr<const Extension> extension = |
| ExtensionBuilder("extension").AddPermission("*://a.com/*").Build(); |
| InitializeAndAddExtension(*extension); |
| EXPECT_FALSE(ScriptingPermissionsModifier(profile(), extension) |
| .HasWithheldHostPermissions()); |
| |
| AddTab(GURL("https://a.com")); |
| |
| Browser* browser = GetBrowser(); |
| ExtensionContextMenuModel menu(extension.get(), browser, |
| ExtensionContextMenuModel::PINNED, nullptr, |
| true, ContextMenuSource::kToolbarAction); |
| EXPECT_EQ(user_action_tester.GetActionCount(kPermissionsPageAction), 0); |
| |
| // "permissions page" button is not visible when the enhanced host controls |
| // feature is disabled. |
| if (!GetParam()) { |
| EXPECT_EQ(GetPageAccessCommandState(menu, kPermissionsPage), |
| CommandState::kAbsent); |
| // There's nothing more we need to test in this case. |
| return; |
| } |
| |
| EXPECT_EQ(GetPageAccessCommandState(menu, kPermissionsPage), |
| CommandState::kEnabled); |
| menu.ExecuteCommand(kPermissionsPage, 0); |
| |
| EXPECT_EQ(browser->tab_strip_model()->count(), 2); |
| content::WebContents* web_contents = |
| browser->tab_strip_model()->GetActiveWebContents(); |
| EXPECT_EQ(user_action_tester.GetActionCount(kPermissionsPageAction), 1); |
| |
| // Test web contents need a poke to commit. |
| content::NavigationController& controller = web_contents->GetController(); |
| content::RenderFrameHostTester::CommitPendingLoad(&controller); |
| |
| EXPECT_EQ(web_contents->GetLastCommittedURL(), |
| GURL(chrome_extension_constants::kExtensionsSitePermissionsURL)); |
| } |
| |
| } // namespace extensions |