// Copyright 2013 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifdef UNSAFE_BUFFERS_BUILD // TODO(crbug.com/40285824): Remove this and convert code to safer constructs. #pragma allow_unsafe_buffers #endif #include "chrome/browser/extensions/extension_service.h" #include <stddef.h> #include <stdint.h> #include <map> #include <memory> #include <optional> #include <set> #include <string> #include <utility> #include <vector> #include "base/command_line.h" #include "base/containers/contains.h" #include "base/files/file_util.h" #include "base/files/scoped_temp_dir.h" #include "base/functional/bind.h" #include "base/json/json_file_value_serializer.h" #include "base/json/json_reader.h" #include "base/json/json_string_value_serializer.h" #include "base/location.h" #include "base/memory/ptr_util.h" #include "base/one_shot_event.h" #include "base/path_service.h" #include "base/ranges/algorithm.h" #include "base/run_loop.h" #include "base/strings/pattern.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_util.h" #include "base/strings/stringprintf.h" #include "base/strings/utf_string_conversions.h" #include "base/task/single_thread_task_runner.h" #include "base/test/bind.h" #include "base/test/gmock_expected_support.h" #include "base/test/metrics/histogram_tester.h" #include "base/test/test_future.h" #include "base/time/time.h" #include "base/values.h" #include "base/version.h" #include "build/build_config.h" #include "build/chromeos_buildflags.h" #include "chrome/browser/background/background_contents_service.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/enterprise/browser_management/management_service_factory.h" #include "chrome/browser/extensions/blocklist.h" #include "chrome/browser/extensions/chrome_app_sorting.h" #include "chrome/browser/extensions/chrome_extension_cookies.h" #include "chrome/browser/extensions/chrome_test_extension_loader.h" #include "chrome/browser/extensions/chrome_zipfile_installer.h" #include "chrome/browser/extensions/component_loader.h" #include "chrome/browser/extensions/crx_installer.h" #include "chrome/browser/extensions/extension_error_ui.h" #include "chrome/browser/extensions/extension_management_test_util.h" #include "chrome/browser/extensions/extension_service_test_base.h" #include "chrome/browser/extensions/extension_service_test_with_install.h" #include "chrome/browser/extensions/extension_special_storage_policy.h" #include "chrome/browser/extensions/extension_util.h" #include "chrome/browser/extensions/external_install_error.h" #include "chrome/browser/extensions/external_install_manager.h" #include "chrome/browser/extensions/external_policy_loader.h" #include "chrome/browser/extensions/external_pref_loader.h" #include "chrome/browser/extensions/external_provider_impl.h" #include "chrome/browser/extensions/external_testing_loader.h" #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h" #include "chrome/browser/extensions/installed_loader.h" #include "chrome/browser/extensions/load_error_reporter.h" #include "chrome/browser/extensions/pack_extension_job.h" #include "chrome/browser/extensions/pending_extension_info.h" #include "chrome/browser/extensions/pending_extension_manager.h" #include "chrome/browser/extensions/permissions/permissions_test_util.h" #include "chrome/browser/extensions/permissions/permissions_updater.h" #include "chrome/browser/extensions/plugin_manager.h" #include "chrome/browser/extensions/preinstalled_apps.h" #include "chrome/browser/extensions/scoped_database_manager_for_test.h" #include "chrome/browser/extensions/test_blocklist.h" #include "chrome/browser/extensions/test_extension_system.h" #include "chrome/browser/extensions/unpacked_installer.h" #include "chrome/browser/extensions/updater/extension_updater.h" #include "chrome/browser/notifications/notification_display_service_tester.h" #include "chrome/browser/policy/policy_test_utils.h" #include "chrome/browser/policy/profile_policy_connector.h" #include "chrome/browser/themes/theme_service.h" #include "chrome/browser/ui/global_error/global_error.h" #include "chrome/browser/ui/global_error/global_error_service.h" #include "chrome/browser/ui/global_error/global_error_service_factory.h" #include "chrome/browser/ui/global_error/global_error_waiter.h" #include "chrome/browser/web_applications/preinstalled_app_install_features.h" #include "chrome/common/chrome_constants.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" #include "chrome/common/pref_names.h" #include "chrome/common/url_constants.h" #include "chrome/grit/browser_resources.h" #include "chrome/grit/generated_resources.h" #include "chrome/test/base/scoped_browser_locale.h" #include "chrome/test/base/testing_profile.h" #include "components/crx_file/id_util.h" #include "components/policy/core/common/management/scoped_management_service_override_for_testing.h" #include "components/policy/core/common/policy_pref_names.h" #include "components/pref_registry/pref_registry_syncable.h" #include "components/prefs/scoped_user_pref_update.h" #include "components/safe_browsing/buildflags.h" #include "components/services/storage/privileged/mojom/indexed_db_control.mojom.h" #include "components/services/storage/privileged/mojom/indexed_db_control_test.mojom.h" #include "components/services/storage/public/mojom/local_storage_control.mojom.h" #include "components/services/storage/public/mojom/storage_usage_info.mojom.h" #include "components/sync/model/string_ordinal.h" #include "components/sync_preferences/pref_service_syncable.h" #include "components/sync_preferences/testing_pref_service_syncable.h" #include "content/public/browser/browser_thread.h" #include "content/public/browser/dom_storage_context.h" #include "content/public/browser/gpu_data_manager.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/storage_partition.h" #include "content/public/common/content_constants.h" #include "content/public/test/browser_task_environment.h" #include "extensions/browser/blocklist_extension_prefs.h" #include "extensions/browser/blocklist_state.h" #include "extensions/browser/disable_reason.h" #include "extensions/browser/extension_creator.h" #include "extensions/browser/extension_file_task_runner.h" #include "extensions/browser/extension_prefs.h" #include "extensions/browser/extension_registry.h" #include "extensions/browser/extension_system.h" #include "extensions/browser/extension_util.h" #include "extensions/browser/external_install_info.h" #include "extensions/browser/external_provider_interface.h" #include "extensions/browser/install_flag.h" #include "extensions/browser/management_policy.h" #include "extensions/browser/mock_external_provider.h" #include "extensions/browser/pref_names.h" #include "extensions/browser/test_extension_registry_observer.h" #include "extensions/browser/test_management_policy.h" #include "extensions/browser/uninstall_reason.h" #include "extensions/browser/updater/extension_downloader_test_helper.h" #include "extensions/browser/updater/null_extension_cache.h" #include "extensions/browser/zipfile_installer.h" #include "extensions/common/extension.h" #include "extensions/common/extension_builder.h" #include "extensions/common/extension_features.h" #include "extensions/common/extension_l10n_util.h" #include "extensions/common/extension_resource.h" #include "extensions/common/extension_urls.h" #include "extensions/common/file_util.h" #include "extensions/common/manifest_constants.h" #include "extensions/common/manifest_handlers/background_info.h" #include "extensions/common/manifest_handlers/content_scripts_handler.h" #include "extensions/common/manifest_handlers/permissions_parser.h" #include "extensions/common/manifest_url_handlers.h" #include "extensions/common/permissions/permission_set.h" #include "extensions/common/permissions/permissions_data.h" #include "extensions/common/switches.h" #include "extensions/common/url_pattern.h" #include "extensions/common/verifier_formats.h" #include "extensions/test/test_extension_dir.h" #include "mojo/public/cpp/bindings/remote.h" #include "net/cookies/canonical_cookie.h" #include "net/cookies/cookie_access_result.h" #include "net/cookies/cookie_options.h" #include "net/cookies/cookie_store.h" #include "net/cookies/cookie_util.h" #include "ppapi/buildflags/buildflags.h" #include "services/network/public/mojom/cookie_manager.mojom.h" #include "services/network/public/mojom/network_context.mojom.h" #include "services/network/public/mojom/network_service.mojom.h" #include "storage/browser/quota/quota_manager.h" #include "storage/browser/quota/quota_manager_proxy.h" #include "storage/common/database/database_identifier.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" #include "testing/platform_test.h" #include "third_party/blink/public/common/storage_key/storage_key.h" #include "third_party/blink/public/mojom/dom_storage/storage_area.mojom.h" #include "ui/base/l10n/l10n_util.h" #include "url/gurl.h" #include "url/origin.h" #if BUILDFLAG(ENABLE_PLUGINS) #include "content/public/browser/plugin_service.h" #endif // The blocklist tests rely on the safe-browsing database. #if BUILDFLAG(SAFE_BROWSING_DB_LOCAL) #define ENABLE_BLOCKLIST_TESTS #endif ScopedObservation; BrowserContext; BrowserThread; DOMStorageContext; APIPermissionID; ManifestLocation; namespace extensions { keys; namespace { // Extension ids used during testing. const char good0[] = …; const char good1[] = …; const char good2[] = …; const char all_zero[] = …; const char good2048[] = …; const char good_crx[] = …; const char minimal_platform_app_crx[] = …; const char hosted_app[] = …; const char page_action[] = …; const char theme_crx[] = …; const char theme2_crx[] = …; const char permissions_crx[] = …; const char updates_from_webstore[] = …; const char updates_from_webstore2[] = …; const char updates_from_webstore3[] = …; const char permissions_blocklist[] = …; const char video_player_app[] = …; const char kPrefBlocklistState[] = …; // A helper value to cast the malware blocklist state to an integer. static constexpr int kBlocklistedMalwareInteger = …; struct BubbleErrorsTestData { … }; static void AddPattern(URLPatternSet* extent, const std::string& pattern) { … } base::FilePath GetTemporaryFile() { … } bool HasExternalInstallErrors(ExtensionService* service) { … } bool HasExternalInstallBubble(ExtensionService* service) { … } size_t GetExternalInstallBubbleCount(ExtensionService* service) { … } scoped_refptr<const Extension> CreateExtension(const std::string& name, const base::FilePath& path, ManifestLocation location) { … } std::unique_ptr<ExternalInstallInfoFile> CreateExternalExtension( const ExtensionId& extension_id, const std::string& version_str, const base::FilePath& path, ManifestLocation location, Extension::InitFromValueFlags flags) { … } // Helper function to persist the passed directories and file paths in // |extension_dir|. Also, writes a generic manifest file. void PersistExtensionWithPaths( const base::FilePath& extension_dir, const std::vector<base::FilePath>& directory_paths, const std::vector<base::FilePath>& file_paths) { … } } // namespace class MockProviderVisitor : public ExternalProviderInterface::VisitorInterface { … }; // Mock provider that can simulate incremental update like // ExternalRegistryLoader. class MockUpdateProviderVisitor : public MockProviderVisitor { … }; struct MockExtensionRegistryObserver : public ExtensionRegistryObserver { … }; class ExtensionLoadedObserver : public ExtensionRegistryObserver { … }; class PendingRemovalObserver : public PendingExtensionManager::Observer { … }; class ExtensionServiceTest : public ExtensionServiceTestWithInstall { … }; // Receives notifications from a PackExtensionJob, indicating either that // packing succeeded or that there was some error. class PackExtensionTestClient : public PackExtensionJob::Client { … }; PackExtensionTestClient::PackExtensionTestClient( const base::FilePath& expected_crx_path, const base::FilePath& expected_private_key_path, base::OnceClosure quit_closure) : … { … } // If packing succeeded, we make sure that the package names match our // expectations. void PackExtensionTestClient::OnPackSuccess( const base::FilePath& crx_path, const base::FilePath& private_key_path) { … } // The tests are designed so that we never expect to see a packing error. void PackExtensionTestClient::OnPackFailure(const std::string& error_message, ExtensionCreator::ErrorType type) { … } // Test loading good extensions from the profile directory. TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) { … } // Test loading bad extensions from the profile directory. TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) { … } // Test various cases for delayed install because of missing imports. TEST_F(ExtensionServiceTest, PendingImports) { … } // Tests that reloading extension with a install delayed due to pending imports // reloads currently installed extension version, rather than installing the // delayed install. TEST_F(ExtensionServiceTest, ReloadExtensionWithPendingImports) { … } // Tests that installation fails with extensions disabled. TEST_F(ExtensionServiceTest, InstallExtensionsWithExtensionsDisabled) { … } // Test installing extensions. This test tries to install few extensions using // crx files. If you need to change those crx files, feel free to repackage // them, throw away the key used and change the id's above. TEST_F(ExtensionServiceTest, InstallExtension) { … } TEST_F(ExtensionServiceTest, InstallExtension_EmitUserHistograms) { … } TEST_F(ExtensionServiceTest, InstallExtension_NonUserEmitHistograms) { … } // Test that correct notifications are sent to ExtensionRegistryObserver on // extension install and uninstall. TEST_F(ExtensionServiceTest, InstallObserverNotified) { … } // Test the handling of uninstalling external extensions. TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) { … } // Tests that uninstalling an external extension, and then reinstalling the // extension as a user install (e.g. from the webstore) succeeds. TEST_F(ExtensionServiceTest, UninstallExternalExtensionAndReinstallAsUser) { … } // Tests uninstalling an external extension from a higher version, and then // installing a lower version as a user. This should succeed. // Regression test for https://crbug.com/795026. TEST_F(ExtensionServiceTest, UninstallExternalExtensionAndReinstallAsUserWithLowerVersion) { … } // Test that uninstalling an external extension does not crash when // the extension could not be loaded. // This extension shown in preferences file requires an experimental permission. // It could not be loaded without such permission. TEST_F(ExtensionServiceTest, UninstallingNotLoadedExtension) { … } // Test that external extensions with incorrect IDs are not installed. // TODO(b/300670172): This test is extremely flaky. TEST_F(ExtensionServiceTest, DISABLED_FailOnWrongId) { … } // Test that external extensions with incorrect versions are not installed. TEST_F(ExtensionServiceTest, FailOnWrongVersion) { … } // Install a user script (they get converted automatically to an extension) TEST_F(ExtensionServiceTest, InstallUserScript) { … } // Extensions don't install during shutdown. TEST_F(ExtensionServiceTest, InstallExtensionDuringShutdown) { … } // This tests that the granted permissions preferences are correctly set when // installing an extension. TEST_F(ExtensionServiceTest, GrantedPermissions) { … } // This tests that the granted permissions stored in prefs ignore internal // permissions specified in the extension manifest. TEST_F(ExtensionServiceTest, GrantedPermissionsIgnoreInternalPermissionsFromManifest) { … } // This tests that the granted permissions preferences are correctly set when // updating an extension, and the extension is disabled in case of a permission // escalation. TEST_F(ExtensionServiceTest, GrantedPermissionsOnUpdate) { … } TEST_F(ExtensionServiceTest, ReenableWithAllPermissionsGranted) { … } TEST_F(ExtensionServiceTest, ReenableWithAllPermissionsGrantedOnStartup) { … } TEST_F(ExtensionServiceTest, DontReenableWithAllPermissionsGrantedButOtherReason) { … } TEST_F(ExtensionServiceTest, DontReenableWithAllPermissionsGrantedOnStartupButOtherReason) { … } // Tests that installing an extension with a permission adds it to the granted // permissions, so that if it is later removed and then re-added the extension // is not disabled. TEST_F(ExtensionServiceTest, ReaddingOldPermissionInUpdateDoesntDisableExtension) { … } // Tests that updating incognito to not_allowed revokes extension's permission // to run in incognito. TEST_F(ExtensionServiceTest, UpdateIncognitoMode) { … } #if !BUILDFLAG(IS_CHROMEOS_ASH) // This tests that the granted permissions preferences are correctly set for // pre-installed apps. TEST_F(ExtensionServiceTest, PreinstalledAppsGrantedPermissions) { … } #endif // Tests that the extension is disabled when permissions are missing from // the extension's granted permissions preferences. (This simulates updating // the browser to a version which recognizes more permissions). TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) { … } // Test Packaging and installing an extension. TEST_F(ExtensionServiceTest, PackExtension) { … } // Test Packaging and installing an extension whose name contains punctuation. TEST_F(ExtensionServiceTest, PackPunctuatedExtension) { … } TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) { … } // Test Packaging and installing an extension using an openssl generated key. // The openssl is generated with the following: // > openssl genrsa -out privkey.pem 1024 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects. TEST_F(ExtensionServiceTest, PackExtensionOpenSSLKey) { … } TEST_F(ExtensionServiceTest, TestInstallThemeWithExtensionsDisabled) { … } #if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN) // Flaky on these platforms. http://crbug.com/1148894 #define MAYBE_InstallTheme … #else #define MAYBE_InstallTheme … #endif TEST_F(ExtensionServiceTest, MAYBE_InstallTheme) { … } TEST_F(ExtensionServiceTest, LoadLocalizedTheme) { … } #if BUILDFLAG(IS_POSIX) TEST_F(ExtensionServiceTest, UnpackedExtensionMayContainSymlinkedFiles) { … } #endif // Tests than an unpacked extension with an empty kMetadataFolder loads // successfully. TEST_F(ExtensionServiceTest, UnpackedExtensionWithEmptyMetadataFolder) { … } // Tests that an unpacked extension with only reserved filenames in the // kMetadataFolder loads successfully. TEST_F(ExtensionServiceTest, UnpackedExtensionWithReservedMetadataFiles) { … } // Tests that an unpacked extension with non-reserved files in the // kMetadataFolder fails to load. TEST_F(ExtensionServiceTest, UnpackedExtensionWithUserMetadataFiles) { … } // Tests than an unpacked extension with an empty kMetadataFolder and a folder // beginning with "_" fails to load. TEST_F(ExtensionServiceTest, UnpackedExtensionWithEmptyMetadataAndUnderscoreFolders) { … } // Tests that an unpacked extension with an arbitrary folder beginning with an // underscore can't load. TEST_F(ExtensionServiceTest, UnpackedExtensionMayNotHaveUnderscore) { … } // Tests that an unpacked extension with a malformed manifest can't reload. // Reload succeeds after fixing the manifest. TEST_F(ExtensionServiceTest, ReloadExtensionWithMalformedManifestAndCorrectManifest) { … } TEST_F(ExtensionServiceTest, InstallLocalizedTheme) { … } TEST_F(ExtensionServiceTest, InstallApps) { … } // Tests that file access is OFF by default for normal packed extensions. TEST_F(ExtensionServiceTest, DefaultPackedFileAccess) { … } // Tests that file access is ON by default for unpacked extensions and the // associated pref is added. TEST_F(ExtensionServiceTest, DefaultUnpackedFileAccess) { … } // Tests that adding a packed extension grants file access if the appropriate // creation flag is set. Note: This doesn't normally happen in practice but it // is tested here to document the behavior. // TODO(crbug.com/40263865): The werid behavior here should be cleared up and we // should simplify how we're storing and checking if file access has been // granted to an extension. TEST_F(ExtensionServiceTest, DefaultPackedFileAccessWithCreationFlag) { … } // Tests that if an extension is created with creation flags granting file // access, but the assocaited pref for file access becomes mismatched to say // that the extension shouldn't have file access, then on the next reload of the // extension (e.g. on Chrome startup) the pref will take precedence. // Regression test for crbug.com/1414398. TEST_F(ExtensionServiceTest, FileAccessFlagAndPrefMismatch) { … } TEST_F(ExtensionServiceTest, UpdateApps) { … } // Verifies that the NTP page and launch ordinals are kept when updating apps. TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) { … } // Ensures that the CWS has properly initialized ordinals. TEST_F(ExtensionServiceTest, EnsureCWSOrdinalsInitialized) { … } TEST_F(ExtensionServiceTest, InstallAppsWithUnlimitedStorage) { … } TEST_F(ExtensionServiceTest, InstallAppsAndCheckStorageProtection) { … } // Test that when an extension version is reinstalled, nothing happens. TEST_F(ExtensionServiceTest, Reinstall) { … } // Test that we can determine if extensions came from the // Chrome web store. TEST_F(ExtensionServiceTest, FromWebStore) { … } // Test upgrading a signed extension. TEST_F(ExtensionServiceTest, UpgradeSignedGood) { … } // Test upgrading a signed extension with a bad signature. TEST_F(ExtensionServiceTest, UpgradeSignedBad) { … } // Test a normal update via the UpdateExtension API TEST_F(ExtensionServiceTest, UpdateExtension) { … } // Extensions should not be updated during browser shutdown. TEST_F(ExtensionServiceTest, UpdateExtensionDuringShutdown) { … } // Test updating a not-already-installed extension - this should fail TEST_F(ExtensionServiceTest, UpdateNotInstalledExtension) { … } // Makes sure you can't downgrade an extension via UpdateExtension TEST_F(ExtensionServiceTest, UpdateWillNotDowngrade) { … } // Make sure calling update with an identical version does nothing TEST_F(ExtensionServiceTest, UpdateToSameVersionIsNoop) { … } // Tests that updating an extension does not clobber old state. TEST_F(ExtensionServiceTest, UpdateExtensionPreservesState) { … } // Tests that updating preserves extension location. TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) { … } // Makes sure that LOAD extension types can downgrade. TEST_F(ExtensionServiceTest, LoadExtensionsCanDowngrade) { … } namespace { bool IsExtension(const Extension* extension, content::BrowserContext* context) { … } #if defined(ENABLE_BLOCKLIST_TESTS) std::set<std::string> StringSet(const std::string& s) { … } std::set<std::string> StringSet(const std::string& s1, const std::string& s2) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) } // namespace // Test adding a pending extension. TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) { … } namespace { const char kGoodId[] = …; const char kGoodUpdateURL[] = …; const char kGoodVersion[] = …; const bool kGoodIsFromSync = …; const bool kGoodRemoteInstall = …; } // namespace // Test installing a pending extension (this goes through // ExtensionService::UpdateExtension). TEST_F(ExtensionServiceTest, UpdatePendingExtension) { … } TEST_F(ExtensionServiceTest, UpdatePendingExtensionWrongVersion) { … } namespace { bool IsTheme(const Extension* extension, content::BrowserContext* context) { … } } // namespace // Test updating a pending theme. TEST_F(ExtensionServiceTest, UpdatePendingTheme) { … } // Test updating a pending CRX as if the source is an external extension // with an update URL. In this case we don't know if the CRX is a theme // or not. TEST_F(ExtensionServiceTest, UpdatePendingExternalCrx) { … } // Test updating a pending CRX as if the source is an external extension // with an update URL. The external update should overwrite a sync update, // but a sync update should not overwrite a non-sync update. TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) { … } // Updating a theme should fail if the updater is explicitly told that // the CRX is not a theme. TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) { … } // TODO(akalin): Test updating a pending extension non-silently once // we can mock out ExtensionInstallUI and inject our version into // UpdateExtension(). // Test updating a pending extension which fails the should-install test. TEST_F(ExtensionServiceTest, UpdatePendingExtensionFailedShouldInstallTest) { … } // TODO(akalin): Figure out how to test that installs of pending // unsyncable extensions are blocked. // Test updating a pending extension for one that is not pending. TEST_F(ExtensionServiceTest, UpdatePendingExtensionNotPending) { … } // Test updating a pending extension for one that is already // installed. TEST_F(ExtensionServiceTest, UpdatePendingExtensionAlreadyInstalled) { … } #if defined(ENABLE_BLOCKLIST_TESTS) // Tests blocklisting then unblocklisting extensions after the service has been // initialized. TEST_F(ExtensionServiceTest, SetUnsetBlocklistInPrefs) { … } // Tests that an extension that was disabled through Omaha won't be // re-enabled if it's not present in the Safe Browsing blocklist. // Regression test for https://crbug.com/1107040. TEST_F(ExtensionServiceTest, NoUnsetBlocklistInPrefs) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Tests trying to install a blocklisted extension. TEST_F(ExtensionServiceTest, BlocklistedExtensionWillNotInstall) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Tests that previously blocklisted extension will be enabled if it is removed // from the blocklist. Also checks that all blocklisted preferences will be // cleared in that case. TEST_F(ExtensionServiceTest, RemoveExtensionFromBlocklist) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Unload blocklisted extension on policy change. TEST_F(ExtensionServiceTest, UnloadBlocklistedExtensionPolicy) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Tests that a blocklisted extension is eventually unloaded on startup, if it // wasn't already. TEST_F(ExtensionServiceTest, WillNotLoadBlocklistedExtensionsFromDirectory) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Tests extensions blocklisted in prefs on startup; one still blocklisted by // safe browsing, the other not. The not-blocklisted one should recover. TEST_F(ExtensionServiceTest, BlocklistedInPrefsFromStartup) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) #if defined(ENABLE_BLOCKLIST_TESTS) // Tests that blocklisted extensions cannot be reloaded, both those loaded // before and after extension service startup. TEST_F(ExtensionServiceTest, ReloadBlocklistedExtension) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) // Tests blocking then unblocking enabled extensions after the service has been // initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockEnabledExtension) { … } // Tests blocking then unblocking disabled extensions after the service has been // initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockDisabledExtension) { … } // Tests blocking then unblocking terminated extensions after the service has // been initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockTerminatedExtension) { … } // Tests blocking then unblocking policy-forced extensions after the service has // been initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockPolicyExtension) { … } #if defined(ENABLE_BLOCKLIST_TESTS) // Tests blocking then unblocking extensions that are blocklisted both before // and after Init(). TEST_F(ExtensionServiceTest, BlockAndUnblockBlocklistedExtension) { … } #endif // defined(ENABLE_BLOCKLIST_TESTS) // Tests blocking then unblocking enabled component extensions after the service // has been initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockEnabledComponentExtension) { … } // Tests blocking then unblocking a theme after the service has been // initialized. TEST_F(ExtensionServiceTest, BlockAndUnblockTheme) { … } // Tests that blocking extensions before Init() results in loading blocked // extensions. TEST_F(ExtensionServiceTest, WillNotLoadExtensionsWhenBlocked) { … } // Tests that IsEnabledExtension won't crash on an uninstalled extension. TEST_F(ExtensionServiceTest, IsEnabledExtensionBlockedAndNotInstalled) { … } // Will not install extension blocklisted by policy. TEST_F(ExtensionServiceTest, BlocklistedByPolicyWillNotInstall) { … } // Extension blocklisted by policy get unloaded after installing. TEST_F(ExtensionServiceTest, BlocklistedByPolicyRemovedIfRunning) { … } // Tests that component extensions are not blocklisted by policy. TEST_F(ExtensionServiceTest, ComponentExtensionAllowlisted) { … } // Tests that active permissions are not revoked from component extensions // by policy when the policy is updated. https://crbug.com/746017. TEST_F(ExtensionServiceTest, ComponentExtensionAllowlistedPermission) { … } // Tests that policy-installed extensions are not blocklisted by policy. TEST_F(ExtensionServiceTest, PolicyInstalledExtensionsAllowlisted) { … } // Tests that extensions cannot be installed if the policy provider prohibits // it. This functionality is implemented in CrxInstaller::ConfirmInstall(). TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsInstall) { … } // Tests that extensions cannot be loaded from prefs if the policy provider // prohibits it. This functionality is implemented in InstalledLoader::Load(). TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsLoadFromPrefs) { … } // Tests disabling an extension when prohibited by the ManagementPolicy. TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsDisable) { … } // Tests uninstalling an extension when prohibited by the ManagementPolicy. TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsUninstall) { … } // Tests that previously installed extensions that are now prohibited from // being installed are disabled. TEST_F(ExtensionServiceTest, ManagementPolicyUnloadsAllProhibited) { … } // Tests that previously disabled extensions that are now required to be // enabled are re-enabled on reinstall. TEST_F(ExtensionServiceTest, ManagementPolicyRequiresEnable) { … } // Tests that extensions disabled by management policy can be installed but // will get disabled after installing. TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsEnableOnInstalled) { … } // Tests that extensions with conflicting required permissions by enterprise // policy cannot be installed. TEST_F(ExtensionServiceTest, PolicyBlockedPermissionNewExtensionInstall) { … } // Tests that extension supposed to be force installed but with conflicting // required permissions cannot be installed. TEST_F(ExtensionServiceTest, PolicyBlockedPermissionConflictsWithForceInstall) { … } // Tests that newer versions of an extension with conflicting required // permissions by enterprise policy cannot be updated to. TEST_F(ExtensionServiceTest, PolicyBlockedPermissionExtensionUpdate) { … } // Tests that policy update with additional permissions blocked revoke // conflicting granted optional permissions and unload extensions with // conflicting required permissions, including the force installed ones. TEST_F(ExtensionServiceTest, PolicyBlockedPermissionPolicyUpdate) { … } // Flaky on windows; http://crbug.com/309833 #if BUILDFLAG(IS_WIN) #define MAYBE_ExternalExtensionAutoAcknowledgement … #else #define MAYBE_ExternalExtensionAutoAcknowledgement … #endif TEST_F(ExtensionServiceTest, MAYBE_ExternalExtensionAutoAcknowledgement) { … } // Tests that an extension added through an external source is initially // disabled with the "prompt for external extensions" feature. TEST_F(ExtensionServiceTest, ExternalExtensionDisabledOnInstallation) { … } // Test that if an extension is installed before the "prompt for external // extensions" feature is enabled, but is updated when the feature is // enabled, the extension is not disabled. TEST_F(ExtensionServiceTest, ExternalExtensionIsNotDisabledOnUpdate) { … } // Test that if an external extension warning is ignored three times, the // extension no longer prompts TEST_F(ExtensionServiceTest, ExternalExtensionRemainsDisabledIfIgnored) { … } // Test that if an external extension becomes force-installed, it's enabled // (even if the user hasn't acknowledged the prompt). TEST_F(ExtensionServiceTest, ExternalExtensionBecomesEnabledIfForceInstalled) { … } #if !BUILDFLAG(IS_CHROMEOS_ASH) // This tests if pre-installed apps are installed correctly. TEST_F(ExtensionServiceTest, PreinstalledAppsInstall) { … } #endif // Tests disabling extensions TEST_F(ExtensionServiceTest, DisableExtension) { … } // Tests the malware Omaha attributes to remotely disable an extension for // malware. TEST_F(ExtensionServiceTest, DisableRemotelyForMalware) { … } // Tests not re-enabling previously remotely disabled extension if it's not the // only reason but the disable reasons should be gone. TEST_F(ExtensionServiceTest, NoEnableRemotelyDisabledExtension) { … } TEST_F(ExtensionServiceTest, CanAddDisableReasonToBlocklistedExtension) { … } // Tests the Extension Telemetry service verdict to remotely disable an // extension for malware. TEST_F(ExtensionServiceTest, DisableRemotelyForMalwareFromExtensionTelemetryServiceVerdict) { … } TEST_F(ExtensionServiceTest, TerminateExtension) { … } TEST_F(ExtensionServiceTest, DisableTerminatedExtension) { … } // Tests that with the kDisableExtensions flag, extensions are not loaded by // the ExtensionService... TEST_F(ExtensionServiceTest, PRE_DisableAllExtensions) { … } // ... But, if we remove the switch, they are. TEST_F(ExtensionServiceTest, DisableAllExtensions) { … } // Tests reloading extensions. TEST_F(ExtensionServiceTest, ReloadExtensions) { … } // Tests reloading an extension. TEST_F(ExtensionServiceTest, ReloadExtension) { … } // TODO(jlulejian): Reuse this in other places in this file. // Test class that sets up an empty extension service before the test starts. class ExtensionServiceWithEmptyServiceTest : public ExtensionServiceTest { … }; TEST_F(ExtensionServiceWithEmptyServiceTest, UninstallExtensionFromWebstore) { … } TEST_F(ExtensionServiceWithEmptyServiceTest, UninstallExtensionFromCrx) { … } TEST_F(ExtensionServiceWithEmptyServiceTest, UninstallExtensionFromUnpackedFolder_DoNotDeleteExtensionFolder) { … } // Test that allows testing the // extensions_features::kExtensionsZipFileInstalledInProfileDir feature for .zip // file installs. class ExtensionServiceZipUninstallProfileFeatureTest : public ExtensionServiceWithEmptyServiceTest, public testing::WithParamInterface<bool> { … }; INSTANTIATE_TEST_SUITE_P(…); TEST_P(ExtensionServiceZipUninstallProfileFeatureTest, UninstallExtensionFromZip) { … } TEST_F(ExtensionServiceWithEmptyServiceTest, UninstallTerminatedExtension) { … } TEST_F(ExtensionServiceWithEmptyServiceTest, UninstallBlockedExtension) { … } // An extension disabled because of unsupported requirements should re-enabled // if updated to a version with supported requirements as long as there are no // other disable reasons. TEST_F(ExtensionServiceTest, UpgradingRequirementsEnabled) { … } // Extensions disabled through user action should stay disabled. TEST_F(ExtensionServiceTest, UpgradingRequirementsDisabled) { … } // The extension should not re-enabled because it was disabled from a // permission increase. TEST_F(ExtensionServiceTest, UpgradingRequirementsPermissions) { … } // Unpacked extensions are not allowed to be installed if they have unsupported // requirements. TEST_F(ExtensionServiceTest, UnpackedRequirements) { … } class ExtensionCookieCallback { … }; // Verifies extension state is removed upon uninstall. TEST_F(ExtensionServiceTest, ClearExtensionData) { … } std::vector<net::CanonicalCookie> IncludedCookies( const net::CookieAccessResultList& result, const net::CookieAccessResultList& excluded) { … } // Verifies app state is removed upon uninstall. TEST_F(ExtensionServiceTest, ClearAppData) { … } // Tests loading single extensions (like --load-extension) TEST_F(ExtensionServiceTest, LoadExtension) { … } // Tests that --load-extension is ignored for users opted in to Enhanced Safe // Browsing (ESB). TEST_F(ExtensionServiceTest, WillNotLoadFromCommandLineForESBUsers) { … } // Tests --load-extension works for non-ESB users. TEST_F(ExtensionServiceTest, LoadsFromCommandLineForNonESBUsers) { … } // Tests that --load-extension is ignored for users with policy // ExtensionInstallTypeBlocklist containing command_line. TEST_F(ExtensionServiceTest, WillNotLoadFromCommandLineForUsersWithPolicyFalse) { … } // Tests --load-extension works for users with policy // ExtensionInstallTypeBlocklist not containing "command_line" (default value) TEST_F(ExtensionServiceTest, LoadsFromCommandLineForUsersWithoutPolicy) { … } // Tests that we generate IDs when they are not specified in the manifest for // --load-extension. TEST_F(ExtensionServiceTest, GenerateID) { … } TEST_F(ExtensionServiceTest, UnpackedValidatesLocales) { … } void ExtensionServiceTest::TestExternalProvider(MockExternalProvider* provider, ManifestLocation location) { … } // Tests the external installation feature #if BUILDFLAG(IS_WIN) TEST_F(ExtensionServiceTest, ExternalInstallRegistry) { // This should all work, even when normal extension installation is disabled. InitializeExtensionServiceWithExtensionsDisabled(); // Now add providers. Extension system takes ownership of the objects. MockExternalProvider* reg_provider = AddMockExternalProvider(ManifestLocation::kExternalRegistry); TestExternalProvider(reg_provider, ManifestLocation::kExternalRegistry); } #endif TEST_F(ExtensionServiceTest, ExternalInstallPref) { … } TEST_F(ExtensionServiceTest, ExternalInstallPrefUpdateUrl) { … } TEST_F(ExtensionServiceTest, ExternalInstallPolicyUpdateUrl) { … } // Tests that external extensions get uninstalled when the external extension // providers can't account for them. TEST_F(ExtensionServiceTest, ExternalUninstall) { … } // Test that running multiple update checks simultaneously does not // keep the update from succeeding. TEST_F(ExtensionServiceTest, MultipleExternalUpdateCheck) { … } TEST_F(ExtensionServiceTest, ExternalPrefProvider) { … } TEST_F(ExtensionServiceTest, ReinstallProviderExtensions) { … } TEST_F(ExtensionServiceTest, DoNotInstallForEnterprise) { … } TEST_F(ExtensionServiceTest, IncrementalUpdateThroughRegistry) { … } // Test loading good extensions from the profile directory. TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) { … } // Test that we get enabled/disabled correctly for all the pref/command-line // combinations. We don't want to derive from the ExtensionServiceTest class // for this test, so we use ExtensionServiceTestSimple. // // Also tests that we always fire EXTENSIONS_READY, no matter whether we are // enabled or not. class ExtensionServiceTestSimple : public testing::Test { … }; TEST_F(ExtensionServiceTestSimple, Enabledness) { … } // Test loading extensions that require limited and unlimited storage quotas. TEST_F(ExtensionServiceTest, StorageQuota) { … } // Tests ComponentLoader::Add(). TEST_F(ExtensionServiceTest, ComponentExtensions) { … } TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) { … } TEST_F(ExtensionServiceTest, FailedLocalFileInstallIsNotPending) { … } TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) { … } TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) { … } // This makes sure we can package and install CRX files that use allowlisted // permissions. TEST_F(ExtensionServiceTest, InstallAllowlistedExtension) { … } // Test that when multiple sources try to install an extension, // we consistently choose the right one. To make tests easy to read, // methods that fake requests to install crx files in several ways // are provided. class ExtensionSourcePriorityTest : public ExtensionServiceTest { … }; // Test that a pending request for installation of an external CRX from // an update URL overrides a pending request to install the same extension // from sync. TEST_F(ExtensionSourcePriorityTest, PendingExternalFileOverSync) { … } // Test that an install of an external CRX from an update overrides // an install of the same extension from sync. TEST_F(ExtensionSourcePriorityTest, PendingExternalUrlOverSync) { … } // Test that an external install request stops sync from installing // the same extension. TEST_F(ExtensionSourcePriorityTest, InstallExternalBlocksSyncRequest) { … } // Test that the blocked pending external extension should be ignored until // it's unblocked. (crbug.com/797369) TEST_F(ExtensionServiceTest, BlockedExternalExtension) { … } // Test that installing an external extension displays a GlobalError. TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) { … } // Test that external extensions are initially disabled, and that enabling // them clears the prompt. TEST_F(ExtensionServiceTest, ExternalInstallInitiallyDisabled) { … } // As for components, only external component extensions can be disabled. TEST_F(ExtensionServiceTest, DisablingComponentExtensions) { … } // Test that installing multiple external extensions works. // Flaky on windows; http://crbug.com/295757 . // Causes race conditions with an in-process utility thread, so disable under // TSan: https://crbug.com/518957 #if BUILDFLAG(IS_WIN) || defined(THREAD_SANITIZER) #define MAYBE_ExternalInstallMultiple … #else #define MAYBE_ExternalInstallMultiple … #endif TEST_F(ExtensionServiceTest, MAYBE_ExternalInstallMultiple) { … } TEST_F(ExtensionServiceTest, MultipleExternalInstallErrors) { … } // Regression test for crbug.com/739142. Verifies that no UAF occurs when // ExternalInstallError needs to be deleted asynchronously. TEST_F(ExtensionServiceTest, InstallPromptAborted) { … } TEST_F(ExtensionServiceTest, MultipleExternalInstallBubbleErrors) { … } // Verifies that an error alert of type BUBBLE_ALERT does not replace an // existing visible alert that was previously opened by clicking menu item. TEST_F(ExtensionServiceTest, BubbleAlertDoesNotHideAnotherAlertFromMenu) { … } // Test that there is a bubble for external extensions that update // from the webstore if the profile is not new. TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreOldProfile) { … } // Test that there is no bubble for external extensions if the profile is new. TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreNewProfile) { … } // Test that clicking to remove the extension on an external install warning // uninstalls the extension. TEST_F(ExtensionServiceTest, ExternalInstallClickToRemove) { … } // Test that clicking to keep the extension on an external install warning // re-enables the extension. TEST_F(ExtensionServiceTest, ExternalInstallClickToKeep) { … } // Test that the external install bubble only takes disabled extensions into // account - enabled extensions, even those that weren't acknowledged, should // not be warned about. This lets us grandfather extensions in. TEST_F(ExtensionServiceTest, ExternalInstallBubbleDoesntShowForEnabledExtensions) { … } TEST_F(ExtensionServiceTest, InstallBlocklistedExtension) { … } // Test that we won't allow enabling a blocklisted extension. TEST_F(ExtensionServiceTest, CannotEnableBlocklistedExtension) { … } // Test that calls to disable Shared Modules do not work. TEST_F(ExtensionServiceTest, CannotDisableSharedModules) { … } // Make sure we can uninstall a blocklisted extension TEST_F(ExtensionServiceTest, UninstallBlocklistedExtension) { … } // Tests a profile being destroyed correctly disables extensions. TEST_F(ExtensionServiceTest, DestroyingProfileClearsExtensions) { … } // Test that updating a corrupt extension removes the DISABLE_CORRUPTED disable // reason. TEST_F(ExtensionServiceTest, CorruptExtensionUpdate) { … } // Try re-enabling a reloading extension. Regression test for crbug.com/676815. TEST_F(ExtensionServiceTest, ReloadAndReEnableExtension) { … } // Test reloading a shared module. Regression test for crbug.com/676815. TEST_F(ExtensionServiceTest, ReloadSharedModule) { … } // Tests that component extensions that have been migrated can be uninstalled. TEST_F(ExtensionServiceTest, UninstallMigratedComponentExtensions) { … } // Tests that component extensions that are not marked as obsolete will not be // uninstalled. TEST_F(ExtensionServiceTest, UninstallMigratedExtensionsKeepsGoodComponents) { … } // Tests that repeat calls to UninstallMigratedExtensions doesn't crash/fail. TEST_F(ExtensionServiceTest, UninstallMigratedExtensionsMultipleCalls) { … } // Tests the case of a user installing a non-policy extension (e.g. through the // webstore), and that extension later becoming required by policy. // Regression test for https://crbug.com/894184. TEST_F(ExtensionServiceTest, UserInstalledExtensionThenRequiredByPolicy) { … } // If the extension is first manually installed by the user, and then added to // the force installed list, on restarting, the extension should behave as a // force installed extension. TEST_F(ExtensionServiceTest, UserInstalledExtensionThenRequiredByPolicyOnRestart) { … } TEST_F(ExtensionServiceTest, InstallingUnacknowledgedExternalExtension) { … } // Regression test for crbug.com/979010. TEST_F(ExtensionServiceTest, ReloadingExtensionFromNotification) { … } #if BUILDFLAG(ENABLE_PLUGINS) // Regression test for crbug.com/460699. Ensure PluginManager doesn't crash even // if OnExtensionUnloaded is invoked twice in succession. TEST_F(ExtensionServiceTest, PluginManagerCrash) { … } #endif // BUILDFLAG(ENABLE_PLUGINS) // Test that blocking extension doesn't trigger unload notification for disabled // extensions. (crbug.com/708230) TEST_F(ExtensionServiceTest, BlockDisabledExtensionNotification) { … } class ExternalExtensionPriorityTest : public ExtensionServiceTest, public testing::WithParamInterface<ManifestLocation> { … }; // Policy-forced extensions should be fetched with FOREGROUND priority, // otherwise they may be throttled (web store sends “noupdate” response to // reduce load), which is OK for updates, but not for a new install. This is // a regression test for problems described in https://crbug.com/904600 and // https://crbug.com/917700. TEST_P(ExternalExtensionPriorityTest, PolicyForegroundFetch) { … } INSTANTIATE_TEST_SUITE_P(…); } // namespace extensions
Codebase Browser
chromium