extension_context_menu_model_unittest.cc

// Copyright 2012 The Chromium Authors
// 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/functional/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 "base/values.h"
#include "build/chromeos_buildflags.h"
#include "chrome/app/chrome_command_ids.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/permissions_test_util.h"
#include "chrome/browser/extensions/permissions/permissions_updater.h"
#include "chrome/browser/extensions/permissions/scripting_permissions_modifier.h"
#include "chrome/browser/extensions/permissions/site_permissions_helper.h"
#include "chrome/browser/extensions/permissions_url_constants.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/toolbar/toolbar_actions_model.h"
#include "chrome/common/extensions/api/context_menus.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/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/test_screen.h"
#include "ui/gfx/image/image.h"
#include "url/origin.h"

namespace extensions {

ManifestLocation;
ContextMenuSource;
MenuEntries;

const MenuEntries kGrantAllExtensions = …;
const MenuEntries kBlockAllExtensions = …;
const MenuEntries kPageAccessSubmenu = …;
const MenuEntries kOnClick = …;
const MenuEntries kOnSite = …;
const MenuEntries kOnAllSites = …;
const MenuEntries kPermissionsPage = …;
const MenuEntries kLearnMore = …;
const MenuEntries kUninstall = …;
const MenuEntries kPolicyInstalled = …;

namespace {

void Increment(int* i, bool granted) { … }

MenuItem::Context MenuItemContextForActionType(ActionInfo::Type type) { … }

scoped_refptr<const Extension> BuildExtensionWithActionType(
    ActionInfo::Type type) { … }

// Label for test extension menu item.
const char* kTestExtensionItemLabel = …;

std::string item_label() { … }

class MenuBuilder { … };

// 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) { … }

// 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) { … }

}  // namespace

class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { … };

ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() { … }

const Extension* ExtensionContextMenuModelTest::AddExtension(
    const std::string& name,
    const char* action_key,
    ManifestLocation location) { … }

const Extension* ExtensionContextMenuModelTest::AddExtensionWithHostPermission(
    const std::string& name,
    const char* action_key,
    ManifestLocation location,
    const std::string& host_permission) { … }

void ExtensionContextMenuModelTest::InitializeAndAddExtension(
    const Extension& extension) { … }

Browser* ExtensionContextMenuModelTest::GetBrowser() { … }

MenuManager* ExtensionContextMenuModelTest::CreateMenuManager() { … }

content::WebContents* ExtensionContextMenuModelTest::AddTab(const GURL& url) { … }

ExtensionContextMenuModelTest::CommandState
ExtensionContextMenuModelTest::GetCommandState(
    const ExtensionContextMenuModel& menu,
    int command_id) const { … }

ExtensionContextMenuModelTest::CommandState
ExtensionContextMenuModelTest::GetPageAccessCommandState(
    const ExtensionContextMenuModel& menu,
    int command) const { … }

bool ExtensionContextMenuModelTest::HasPageAccessSubmenu(
    const ExtensionContextMenuModel& menu) const { … }

bool ExtensionContextMenuModelTest::HasCantAccessPageEntry(
    const ExtensionContextMenuModel& menu) const { … }

void ExtensionContextMenuModelTest::SetUp() { … }

void ExtensionContextMenuModelTest::TearDown() { … }

// Tests that applicable menu items are disabled when a ManagementPolicy
// prohibits them.
TEST_F(ExtensionContextMenuModelTest, RequiredInstallationsDisablesItems) { … }

// Tests the context menu for a component extension.
TEST_F(ExtensionContextMenuModelTest, ComponentExtensionContextMenu) { … }

// Tests that the standard menu items (home page, uninstall, manage
// extensions, view web permissions) 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) { … }

TEST_F(ExtensionContextMenuModelTest,
       ExtensionContextMenuToggleVisibilityEntryVisibility) { … }

TEST_F(ExtensionContextMenuModelTest,
       ExtensionContextMenuOptionsEntryVisibility) { … }

// 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) { … }

// Test that the "pin" and "unpin" menu items appear correctly in the extension
// context menu with toolbar action source.
TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuShowAndHide) { … }

// Test that the "pin" and "unpin" menu items is disabled when the extension is
// force-pinned via ExtensionSettings.
TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuForcePinned) { … }

TEST_F(ExtensionContextMenuModelTest, ExtensionContextUninstall) { … }

TEST_F(ExtensionContextMenuModelTest, PageAccess_CustomizeByExtension_Submenu) { … }

// Tests different permission patterns when the site setting is set to
// "customize by extension".
TEST_F(ExtensionContextMenuModelTest,
       PageAccess_CustomizeByExtension_PermissionPatterns) { … }

// 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) { … }

// 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) { … }

TEST_F(ExtensionContextMenuModelTest,
       PageAccess_CustomizeByExtension_WithActiveTab) { … }

// Test that when there is a page navigation with the menu open the page access
// commands stay the same but we don't update site access when executing their
// actions.
TEST_F(ExtensionContextMenuModelTest,
       PageAccess_CustomizeByExtension_PageNavigation) { … }

TEST_F(ExtensionContextMenuModelTest,
       TestTogglingAccessWithSpecificSitesWithUnrequestedUrl) { … }

TEST_F(ExtensionContextMenuModelTest,
       TestTogglingAccessWithSpecificSitesWithRequestedSites) { … }

TEST_F(ExtensionContextMenuModelTest, TestClickingPageAccessLearnMore) { … }

TEST_F(ExtensionContextMenuModelTest, HistogramTest_Basic) { … }

TEST_F(ExtensionContextMenuModelTest, HistogramTest_CustomCommand) { … }

class ExtensionActionContextMenuModelTest
    : public ExtensionContextMenuModelTest,
      public testing::WithParamInterface<ActionInfo::Type> { … };

TEST_P(ExtensionActionContextMenuModelTest,
       MenuItemShowsOnlyForAppropriateActionType) { … }

TEST_P(ExtensionActionContextMenuModelTest, ActionMenuItemsAreLimited) { … }

// Tests that top-level items adjust according to the visibility of others
// in the list.
TEST_P(ExtensionActionContextMenuModelTest,
       ActionItemsOverTheLimitAreShownIfSomeOthersAreHidden) { … }

INSTANTIATE_TEST_SUITE_P(…);

class ExtensionContextMenuModelWithUserHostControlsTest
    : public ExtensionContextMenuModelTest,
      public testing::WithParamInterface<bool> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(ExtensionContextMenuModelWithUserHostControlsTest,
       PageAccessItemsVisibilityBasedOnSiteSettings) { … }

TEST_P(ExtensionContextMenuModelWithUserHostControlsTest,
       PageAccessItemsVisibility_PolicyInstalled) { … }

TEST_P(ExtensionContextMenuModelWithUserHostControlsTest,
       PolicyInstalledEntryVisibilityBasedOnSiteSettings) { … }

// Tests that the uninstall entry is only visible for extensions that can be
// uninstalled (e.g non-enterprise extensions).
TEST_P(ExtensionContextMenuModelWithUserHostControlsTest,
       UninstallEntryVisibility) { … }

// Test clicking on the "permissions page" item opens the correct link.
TEST_P(ExtensionContextMenuModelWithUserHostControlsTest,
       TestClickingPageAccessPermissionsPage) { … }

class ExtensionContextMenuModelWithUserHostControlsAndPermittedSitesTest
    : public ExtensionContextMenuModelWithUserHostControlsTest { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(ExtensionContextMenuModelWithUserHostControlsAndPermittedSitesTest,
       PageAccessItemsVisibilityBasedOnSiteSettings) { … }

}  // namespace extensions
chromium/chrome/browser/extensions/extension_context_menu_model_unittest.cc
