// Copyright 2025 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/api/developer_private/developer_private_functions.h" #include #include #include #include #include #include #include #include "base/barrier_closure.h" #include "base/debug/crash_logging.h" #include "base/files/file_util.h" #include "base/memory/ref_counted.h" #include "base/metrics/histogram_functions.h" #include "base/strings/strcat.h" #include "base/strings/stringprintf.h" #include "base/strings/utf_string_conversions.h" #include "base/task/thread_pool.h" #include "chrome/browser/devtools/devtools_window.h" #include "chrome/browser/extensions/api/developer_private/developer_private_api.h" #include "chrome/browser/extensions/api/developer_private/developer_private_event_router.h" #include "chrome/browser/extensions/api/developer_private/extension_info_generator.h" #include "chrome/browser/extensions/api/developer_private/profile_info_generator.h" #include "chrome/browser/extensions/chrome_zipfile_installer.h" #include "chrome/browser/extensions/devtools_util.h" #include "chrome/browser/extensions/extension_commands_global_registry.h" #include "chrome/browser/extensions/extension_management.h" #include "chrome/browser/extensions/extension_service.h" #include "chrome/browser/extensions/extension_tab_util.h" #include "chrome/browser/extensions/extension_ui_util.h" #include "chrome/browser/extensions/extension_util.h" #include "chrome/browser/extensions/install_verifier_factory.h" #include "chrome/browser/extensions/sync/account_extension_tracker.h" #include "chrome/browser/extensions/sync/extension_sync_util.h" #include "chrome/browser/extensions/updater/extension_updater.h" #include "chrome/browser/extensions/webstore_reinstaller.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/signin/identity_manager_factory.h" #include "chrome/browser/supervised_user/supervised_user_browser_utils.h" #include "chrome/browser/ui/extensions/extension_multiple_uninstall_dialog.h" #include "chrome/browser/ui/extensions/upload_extension_to_account_dialog.h" #include "chrome/browser/ui/safety_hub/menu_notification_service_factory.h" #include "chrome/browser/ui/select_file_policy/chrome_select_file_policy.h" #include "chrome/browser/ui/toolbar/toolbar_actions_model.h" #include "chrome/common/pref_names.h" #include "chrome/common/url_constants.h" #include "chrome/grit/generated_resources.h" #include "components/policy/core/common/policy_pref_names.h" #include "components/prefs/pref_service.h" #include "components/signin/public/base/signin_switches.h" #include "components/sync/base/features.h" #include "content/public/common/drop_data.h" #include "extensions/browser/crx_installer.h" #include "extensions/browser/disable_reason.h" #include "extensions/browser/extension_file_task_runner.h" #include "extensions/browser/extension_prefs.h" #include "extensions/browser/extension_registrar.h" #include "extensions/browser/extension_registry.h" #include "extensions/browser/extension_system.h" #include "extensions/browser/file_highlighter.h" #include "extensions/browser/install_verifier.h" #include "extensions/browser/management_policy.h" #include "extensions/browser/manifest_v2_handler.h" #include "extensions/browser/path_util.h" #include "extensions/browser/permissions/permissions_updater.h" #include "extensions/browser/permissions/scripting_permissions_modifier.h" #include "extensions/browser/permissions/site_permissions_helper.h" #include "extensions/browser/permissions_manager.h" #include "extensions/browser/ui_util.h" #include "extensions/browser/unpacked_installer.h" #include "extensions/browser/user_script_manager.h" #include "extensions/buildflags/buildflags.h" #include "extensions/common/manifest_constants.h" #include "extensions/common/manifest_handlers/background_info.h" #include "extensions/common/manifest_handlers/options_page_info.h" #include "extensions/common/permissions/permissions_data.h" #include "net/base/filename_util.h" #include "third_party/re2/src/re2/re2.h" #include "ui/base/clipboard/file_info.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/window_open_disposition.h" #if BUILDFLAG(IS_ANDROID) #include "chrome/browser/ui/android/extensions/extension_developer_private_bridge.h" #include "chrome/common/extensions/api/developer_private.h" #include "extensions/browser/extension_function.h" #else // BUILDFLAG(IS_ANDROID) #include "base/check_is_test.h" #include "base/functional/bind.h" #include "base/functional/callback.h" #include "base/functional/callback_helpers.h" #include "base/lazy_instance.h" #include "base/memory/scoped_refptr.h" #include "base/notreached.h" #include "base/strings/string_number_conversions.h" #include "base/types/expected.h" #include "base/uuid.h" #include "chrome/browser/platform_util.h" #include "chrome/browser/ui/browser_window.h" #include "chrome/browser/ui/browser_window/public/browser_window_interface.h" #include "chrome/browser/ui/browser_window/public/global_browser_collection.h" #include "chrome/browser/ui/browser_window/public/profile_browser_collection.h" #include "chrome/browser/ui/extensions/application_launch.h" #include "chrome/browser/ui/safety_hub/safety_hub_constants.h" #include "chrome/browser/ui/tabs/tab_strip_model.h" #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" #include "chrome/common/url_constants.h" #include "components/signin/public/identity_manager/identity_manager.h" #include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_thread.h" #include "content/public/browser/render_frame_host.h" #include "content/public/browser/site_instance.h" #include "content/public/browser/storage_partition.h" #include "content/public/browser/web_contents.h" #include "extensions/browser/api/file_handlers/app_file_handler_util.h" #include "extensions/browser/error_map.h" #include "extensions/browser/extension_util.h" #include "extensions/browser/process_manager_factory.h" #include "extensions/browser/ui_util.h" #include "extensions/browser/updater/extension_downloader_types.h" #include "extensions/browser/zipfile_installer.h" #include "extensions/common/extension_features.h" #include "extensions/common/extension_id.h" #include "extensions/common/extension_set.h" #include "extensions/common/feature_switch.h" #include "extensions/common/install_warning.h" #include "extensions/common/manifest.h" #include "extensions/common/manifest_handlers/manifest_url_handlers.h" #include "extensions/common/mojom/context_type.mojom.h" #include "extensions/common/url_pattern.h" #include "extensions/common/url_pattern_set.h" #include "net/base/registry_controlled_domains/registry_controlled_domain.h" #include "storage/browser/blob/shareable_file_reference.h" #include "storage/browser/file_system/external_mount_points.h" #include "storage/browser/file_system/file_system_context.h" #include "storage/browser/file_system/file_system_operation.h" #include "storage/browser/file_system/file_system_operation_runner.h" #include "storage/browser/file_system/isolated_context.h" #include "third_party/blink/public/common/storage_key/storage_key.h" #include "ui/base/base_window.h" #include "ui/shell_dialogs/selected_file_info.h" #include "url/gurl.h" #include "url/origin.h" #endif // BUILDFLAG(IS_ANDROID) static_assert(BUILDFLAG(ENABLE_EXTENSIONS_CORE)); namespace extensions { namespace developer = api::developer_private; namespace { #if !BUILDFLAG(IS_ANDROID) constexpr char kUnpackedAppsFolder[] = "apps_target"; #endif // !BUILDFLAG(IS_ANDROID) const char kCannotUpdateChildAccountProfileSettingsError[] = "Cannot change settings for a child account profile."; ui::FileInfo* g_drop_file_for_testing = nullptr; std::string ReadFileToString(const base::FilePath& path) { std::string data; // This call can fail, but it doesn't matter for our purposes. If it fails, // we simply return an empty string for the manifest, and ignore it. std::ignore = base::ReadFileToString(path, &data); return data; } std::optional ParseRuntimePermissionsPattern( const std::string& pattern_str) { constexpr int kValidRuntimePermissionSchemes = URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS | URLPattern::SCHEME_FILE; URLPattern pattern(kValidRuntimePermissionSchemes); if (pattern.Parse(pattern_str) != URLPattern::ParseResult::kSuccess) { return std::nullopt; } // We don't allow adding paths for permissions, because they aren't meaningful // in terms of origin access. The frontend should validate this, but there's // a chance something can slip through, so we should fail gracefully. if (pattern.path() != "/*") { return std::nullopt; } return pattern; } GURL ConvertHostToUrl(const std::string& host) { return GURL(base::StrCat( {url::kHttpScheme, url::kStandardSchemeSeparator, host, "/"})); } // Runs the install verifier for all extensions that are enabled, disabled, or // terminated. void PerformVerificationCheck(content::BrowserContext* context) { const ExtensionSet extensions = ExtensionRegistry::Get(context)->GenerateInstalledExtensionsSet( ExtensionRegistry::ENABLED | ExtensionRegistry::DISABLED | ExtensionRegistry::TERMINATED); ExtensionPrefs* prefs = ExtensionPrefs::Get(context); bool should_do_verification_check = false; for (const scoped_refptr& extension : extensions) { if (ui_util::ShouldDisplayInExtensionSettings(*extension) && prefs->HasDisableReason(extension->id(), disable_reason::DISABLE_NOT_VERIFIED)) { should_do_verification_check = true; break; } } if (should_do_verification_check) { InstallVerifierFactory::GetForBrowserContext(context) ->VerifyAllExtensions(); } } std::string GetETldPlusOne(const GURL& site) { DCHECK(site.is_valid()); std::string etld_plus_one = net::registry_controlled_domains::GetDomainAndRegistry( site, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); return etld_plus_one.empty() ? site.GetHost() : etld_plus_one; } developer::SiteInfo CreateSiteInfo(const std::string& site, developer::SiteSet site_set, size_t num_extensions = 0u) { developer::SiteInfo site_info; site_info.site = site; site_info.site_set = site_set; site_info.num_extensions = num_extensions; return site_info; } // Adds `site` grouped under `etld_plus_one` into `site_groups`. This function // is a no-op if `site` already exists inside the SiteGroup for `etld_plus_one`. void AddSiteToSiteGroups( std::map* site_groups, const std::string& site, const std::string& etld_plus_one, developer::SiteSet site_set) { auto [it, inserted] = site_groups->try_emplace(etld_plus_one); if (inserted) { it->second.etld_plus_one = etld_plus_one; it->second.sites.push_back(CreateSiteInfo(site, site_set)); } else if (!std::ranges::contains(it->second.sites, site, &developer::SiteInfo::site)) { it->second.sites.push_back(CreateSiteInfo(site, site_set)); } } // Adds an extension's granted host permissions in `distinct_hosts` to // `site_groups`, void ProcessSitesForRuntimeHostPermissions( std::map* site_groups, const std::vector& distinct_hosts) { for (const auto& pattern : distinct_hosts) { // Do not add the pattern if it matches an overly broad set of urls (all // urls under one or all top level domains). if (pattern.match_all_urls() || pattern.host().empty() || pattern.MatchesEffectiveTld()) { continue; } std::string etld_plus_one = GetETldPlusOne(ConvertHostToUrl(pattern.host())); // Process the site if: // 1) It does not match any subdomains, or: // 2) It matches subdomains but the host portion does not equal // `etld_plus_one`. This treats patterns such as "*.sub.etldplusone.com" // as just "sub.etldplusone.com" and prevents "*.etldplusone.com" from // being processed as "etldplusone.com", since such patterns will be // processed separately. if (!pattern.match_subdomains() || pattern.host() != etld_plus_one) { AddSiteToSiteGroups(site_groups, pattern.host(), etld_plus_one, developer::SiteSet::kExtensionSpecified); } } } // Updates num_extensions counts in `site_groups` for `granted_hosts` from one // extension. void UpdateSiteGroupCountsForExtensionHosts( std::map* site_groups, std::map* match_subdomains_count, const URLPatternSet& granted_hosts) { for (auto& entry : *site_groups) { bool can_run_on_site_group = false; // For each site under the eTLD+1, increment num_extensions if the extension // can access the site. for (developer::SiteInfo& site_info : entry.second.sites) { // When updating num_extensions counts, only look at extension specified // hosts as num_extensions is not useful for user specified hosts. (i.e. // user permitted sites can be accessed to any extensions that specify the // site in their host permissions, user restricted sites cannot be // accessed by any extensions.) if (site_info.site_set != developer::SiteSet::kExtensionSpecified) { continue; } if (granted_hosts.MatchesHost(ConvertHostToUrl(site_info.site), /*require_match_subdomains=*/false)) { can_run_on_site_group = true; site_info.num_extensions++; } } // Check if the extension can run on all sites under this eTLD+1 and // update `match_subdomains_count` for this eTLD+1. The SiteInfo entry will // be created later if at least one extension can run on all subdomains. if (granted_hosts.MatchesHost(ConvertHostToUrl(entry.first), /*require_match_subdomains=*/true)) { (*match_subdomains_count)[entry.first]++; can_run_on_site_group = true; } if (can_run_on_site_group) { entry.second.num_extensions++; } } } // Sets the dropped path to DeveloperPrivateAPI. base::expected SetDroppedPath( content::WebContents* web_contents, content::BrowserContext* context) { const ui::FileInfo* file_info = nullptr; if (g_drop_file_for_testing) { file_info = g_drop_file_for_testing; } else { content::DropData* drop_data = web_contents->GetDropData(); if (!drop_data) { return base::unexpected{"No current drop data."}; } if (drop_data->filenames.empty()) { return base::unexpected{"No files being dropped."}; } file_info = &drop_data->filenames.front(); } DCHECK(file_info); // Note(devlin): we don't do further validation that the file is a directory // here. This is validated in the JS, but if that fails, then trying to load // the file as an unpacked extension will also fail (reasonably gracefully). DeveloperPrivateAPI::Get(context)->SetDraggedFile(web_contents, *file_info); return base::ok(); } // Returns whether the filename perceived to the user ends with the extension. // Just using `path` is not enough because it might be a content URI that // doesn't have the `display_name` as a suffix. bool MatchesExtension(ui::FileInfo& file_info, base::FilePath::StringViewType extension) { return file_info.display_name.empty() ? file_info.path.MatchesExtension(extension) : file_info.display_name.MatchesExtension(extension); } } // namespace #if !BUILDFLAG(IS_ANDROID) namespace ChoosePath = api::developer_private::ChoosePath; namespace PackDirectory = api::developer_private::PackDirectory; namespace Reload = api::developer_private::Reload; #endif // !BUILDFLAG(IS_ANDROID) namespace api { void DeveloperPrivateAPIFunction::GetManifestError( const std::u16string& error, const base::FilePath& extension_path, GetManifestErrorCallback callback) { size_t line = 0u; size_t column = 0u; std::string regex = base::StringPrintf("%s Line: (\\d+), column: (\\d+), .*", manifest_errors::kManifestParseError); // If this was a JSON parse error, we can highlight the exact line with the // error. Otherwise, we should still display the manifest (for consistency, // reference, and so that if we ever make this really fancy and add an editor, // it's ready). // // This regex call can fail, but if it does, we just don't highlight anything. re2::RE2::FullMatch(base::UTF16ToUTF8(error), regex, &line, &column); // This will read the manifest and call AddFailure with the read manifest // contents. base::ThreadPool::PostTaskAndReplyWithResult( FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_BLOCKING}, base::BindOnce(&ReadFileToString, extension_path.Append(kManifestFilename)), base::BindOnce(std::move(callback), extension_path, error, line)); } developer::LoadError DeveloperPrivateAPIFunction::CreateLoadError( const base::FilePath& file_path, const std::u16string& error, size_t line_number, const std::string& manifest, const DeveloperPrivateAPI::UnpackedRetryId& retry_guid) { base::FilePath prettified_path = path_util::PrettifyPath(file_path); SourceHighlighter highlighter(manifest, line_number); developer::LoadError response; response.error = base::UTF16ToUTF8(error); response.path = base::UTF16ToUTF8(prettified_path.LossyDisplayName()); response.retry_guid = retry_guid; response.source.emplace(); response.source->before_highlight = highlighter.GetBeforeFeature(); response.source->highlight = highlighter.GetFeature(); response.source->after_highlight = highlighter.GetAfterFeature(); return response; } DeveloperPrivateAPIFunction::~DeveloperPrivateAPIFunction() = default; const Extension* DeveloperPrivateAPIFunction::GetExtensionById( const ExtensionId& id) { return ExtensionRegistry::Get(browser_context()) ->GetExtensionById(id, ExtensionRegistry::EVERYTHING); } const Extension* DeveloperPrivateAPIFunction::GetEnabledExtensionById( const ExtensionId& id) { return ExtensionRegistry::Get(browser_context()) ->enabled_extensions() .GetByID(id); } DeveloperPrivateAPIFunction::ResponseValue DeveloperPrivateAPIFunction::LogNoSuchExtensionFoundAndReturn() { base::UmaHistogramSparse( "Extensions.Functions.DeveloperPrivate.NoSuchExtensionErrorThrown", histogram_value()); return Error(ErrorUtils::FormatErrorMessage(kNoSuchExtensionError, name())); } DeveloperPrivateAutoUpdateFunction::~DeveloperPrivateAutoUpdateFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateAutoUpdateFunction::Run() { Profile* profile = Profile::FromBrowserContext(browser_context()); ExtensionUpdater* updater = ExtensionUpdater::Get(profile); if (updater->enabled()) { ExtensionUpdater::CheckParams params; params.fetch_priority = DownloadFetchPriority::kForeground; params.install_immediately = true; params.callback = base::BindOnce(&DeveloperPrivateAutoUpdateFunction::OnComplete, this); updater->CheckNow(std::move(params)); } return RespondLater(); } void DeveloperPrivateAutoUpdateFunction::OnComplete() { Respond(NoArguments()); } DeveloperPrivateGetExtensionsInfoFunction:: DeveloperPrivateGetExtensionsInfoFunction() = default; DeveloperPrivateGetExtensionsInfoFunction:: ~DeveloperPrivateGetExtensionsInfoFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetExtensionsInfoFunction::Run() { std::optional params = developer::GetExtensionsInfo::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); bool include_disabled = true; bool include_terminated = true; if (params->options) { if (params->options->include_disabled) { include_disabled = *params->options->include_disabled; } if (params->options->include_terminated) { include_terminated = *params->options->include_terminated; } } info_generator_ = std::make_unique(browser_context()); info_generator_->CreateExtensionsInfo( include_disabled, include_terminated, base::BindOnce( &DeveloperPrivateGetExtensionsInfoFunction::OnInfosGenerated, this)); return RespondLater(); } void DeveloperPrivateGetExtensionsInfoFunction::OnInfosGenerated( ExtensionInfoGenerator::ExtensionInfoList list) { Respond(ArgumentList(developer::GetExtensionsInfo::Results::Create(list))); } DeveloperPrivateGetExtensionInfoFunction:: DeveloperPrivateGetExtensionInfoFunction() = default; DeveloperPrivateGetExtensionInfoFunction:: ~DeveloperPrivateGetExtensionInfoFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetExtensionInfoFunction::Run() { std::optional params = developer::GetExtensionInfo::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); info_generator_ = std::make_unique(browser_context()); info_generator_->CreateExtensionInfo( params->id, base::BindOnce( &DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated, this)); return RespondLater(); } void DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated( ExtensionInfoGenerator::ExtensionInfoList list) { DCHECK_LE(1u, list.size()); Respond(list.empty() ? LogNoSuchExtensionFoundAndReturn() : WithArguments(list[0].ToValue())); } DeveloperPrivateGetExtensionSizeFunction:: DeveloperPrivateGetExtensionSizeFunction() = default; DeveloperPrivateGetExtensionSizeFunction:: ~DeveloperPrivateGetExtensionSizeFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetExtensionSizeFunction::Run() { std::optional params = developer::GetExtensionSize::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetExtensionById(params->id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } extensions::path_util::CalculateAndFormatExtensionDirectorySize( extension->path(), IDS_APPLICATION_INFO_SIZE_SMALL_LABEL, base::BindOnce( &DeveloperPrivateGetExtensionSizeFunction::OnSizeCalculated, this)); return RespondLater(); } void DeveloperPrivateGetExtensionSizeFunction::OnSizeCalculated( const std::u16string& size) { Respond(WithArguments(size)); } DeveloperPrivateGetProfileConfigurationFunction:: ~DeveloperPrivateGetProfileConfigurationFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetProfileConfigurationFunction::Run() { developer::ProfileInfo info = CreateProfileInfo(Profile::FromBrowserContext(browser_context())); // If this is called from the chrome://extensions page, we use this as a // heuristic that it's a good time to verify installs. We do this on startup, // but there's a chance that it failed erroneously, so it's good to double- // check. if (source_context_type() == mojom::ContextType::kWebUi) { PerformVerificationCheck(browser_context()); } return RespondNow(WithArguments(info.ToValue())); } DeveloperPrivateUpdateProfileConfigurationFunction:: ~DeveloperPrivateUpdateProfileConfigurationFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateUpdateProfileConfigurationFunction::Run() { std::optional params = developer::UpdateProfileConfiguration::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const developer::ProfileConfigurationUpdate& update = params->update; Profile* profile = Profile::FromBrowserContext(browser_context()); CHECK(profile); if (update.in_developer_mode) { if (supervised_user::AreExtensionsPermissionsEnabled(profile)) { return RespondNow(Error(kCannotUpdateChildAccountProfileSettingsError)); } util::SetDeveloperModeForProfile(profile, *update.in_developer_mode); } if (update.extensions_pinned_by_default) { profile->GetPrefs()->SetBoolean(prefs::kExtensionsPinnedByDefault, *update.extensions_pinned_by_default); base::UmaHistogramBoolean("Extensions.Settings.DefaultPinningToggled", *update.extensions_pinned_by_default); } if (update.is_mv2_deprecation_notice_dismissed.value_or(false)) { ManifestV2Handler::Get(browser_context()) ->MarkNoticeAsAcknowledgedGlobally(); } return RespondNow(NoArguments()); } DeveloperPrivateUpdateExtensionConfigurationFunction:: ~DeveloperPrivateUpdateExtensionConfigurationFunction() = default; DeveloperPrivateOpenReviewPageFunction:: ~DeveloperPrivateOpenReviewPageFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateOpenReviewPageFunction::Run() { std::optional params = developer::OpenReviewPage::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } Profile* profile = Profile::FromBrowserContext(browser_context()); CHECK(profile); if (!profile->GetPrefs()->GetBoolean(prefs::kExtensionReviewPromptsAllowed)) { return RespondNow(Error("Review prompts are disabled by policy.")); } if (!ui_util::ShouldShowReviewPrompt(*extension, *profile)) { return RespondNow(Error("The extension is ineligible for review prompts.")); } content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } GURL review_url = util::GetCWSWritingReviewUrl( params->extension_id, util::CWSReviewSource::kExtensionsPage); ExtensionTabUtil::NavigateToURL(WindowOpenDisposition::NEW_FOREGROUND_TAB, web_contents, review_url, base::DoNothing()); return RespondNow(NoArguments()); } ExtensionFunction::ResponseAction DeveloperPrivateUpdateExtensionConfigurationFunction::Run() { std::optional params = developer::UpdateExtensionConfiguration::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const developer::ExtensionConfigurationUpdate& update = params->update; const Extension* extension = GetExtensionById(update.extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } // The chrome://extensions page uses toggles which, when dragged, do not // invoke a user gesture. Work around this for the chrome://extensions page. // TODO(dpapad): Remove this exemption when sliding a toggle counts as a // gesture. bool allowed = source_context_type() == mojom::ContextType::kWebUi || user_gesture(); if (!allowed) { return RespondNow(Error(kRequiresUserGestureError)); } if (update.file_access) { // `util::SetAllowFileAccess()` can synchronously reload the extension, // invalidating the `extension` pointer. We pass `update.extension_id` // to ensure the ID reference stays alive, and re-fetch the pointer after. util::SetAllowFileAccess(update.extension_id, browser_context(), *update.file_access); extension = GetExtensionById(update.extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } } if (update.incognito_access) { // `util::SetIsIncognitoEnabled()` can also synchronously reload the // extension. util::SetIsIncognitoEnabled(update.extension_id, browser_context(), *update.incognito_access); extension = GetExtensionById(update.extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } } if (update.user_scripts_access) { ExtensionSystem::Get(browser_context()) ->user_script_manager() ->SetUserScriptPrefEnabled(update.extension_id, *update.user_scripts_access); } if (update.error_collection) { ErrorConsole::Get(browser_context()) ->SetReportingAllForExtension(update.extension_id, *update.error_collection); } if (update.host_access != developer::HostAccess::kNone) { PermissionsManager* manager = PermissionsManager::Get(browser_context()); if (!manager->CanAffectExtension(*extension)) { return RespondNow(Error(kCannotChangeHostPermissions)); } ScriptingPermissionsModifier modifier(browser_context(), extension); switch (update.host_access) { case developer::HostAccess::kOnClick: modifier.SetWithholdHostPermissions(true); modifier.RemoveAllGrantedHostPermissions(); break; case developer::HostAccess::kOnSpecificSites: if (manager->HasBroadGrantedHostPermissions(*extension)) { modifier.RemoveBroadGrantedHostPermissions(); } modifier.SetWithholdHostPermissions(true); break; case developer::HostAccess::kOnAllSites: modifier.SetWithholdHostPermissions(false); break; case developer::HostAccess::kNone: NOTREACHED(); } } if (update.acknowledge_safety_check_warning_reason != developer_private::SafetyCheckWarningReason::kNone) { ExtensionPrefs::Get(browser_context()) ->SetIntegerPref( update.extension_id, kPrefAcknowledgeSafetyCheckWarningReason, static_cast(update.acknowledge_safety_check_warning_reason)); DeveloperPrivateEventRouter* event_router = DeveloperPrivateAPI::Get(browser_context()) ->developer_private_event_router(); if (event_router) { event_router->OnExtensionConfigurationChanged(update.extension_id); } } if (update.show_access_requests_in_toolbar) { SitePermissionsHelper(Profile::FromBrowserContext(browser_context())) .SetShowAccessRequestsInToolbar( update.extension_id, *update.show_access_requests_in_toolbar); } if (update.pinned_to_toolbar) { ToolbarActionsModel* toolbar_actions_model = ToolbarActionsModel::Get( Profile::FromBrowserContext(browser_context())); if (!toolbar_actions_model->HasAction(update.extension_id)) { return RespondNow(Error(kCannotSetPinnedWithoutAction)); } bool is_action_pinned = toolbar_actions_model->IsActionPinned(update.extension_id); if (is_action_pinned != *update.pinned_to_toolbar) { toolbar_actions_model->SetActionVisibility(update.extension_id, !is_action_pinned); } } return RespondNow(NoArguments()); } DeveloperPrivateReloadFunction::DeveloperPrivateReloadFunction() = default; DeveloperPrivateReloadFunction::~DeveloperPrivateReloadFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() { std::optional params = developer_private::Reload::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } reloading_extension_path_ = extension->path(); bool fail_quietly = false; bool wait_for_completion = false; if (params->options) { fail_quietly = params->options->fail_quietly && *params->options->fail_quietly; // We only wait for completion for unpacked extensions, since they are the // only extensions for which we can show actionable feedback to the user. wait_for_completion = params->options->populate_error_for_unpacked && *params->options->populate_error_for_unpacked && Manifest::IsUnpackedLocation(extension->location()); } ExtensionRegistrar* registrar = ExtensionRegistrar::Get(browser_context()); if (fail_quietly) { registrar->ReloadExtensionWithQuietFailure(params->extension_id); } else { registrar->ReloadExtension(params->extension_id); } if (!wait_for_completion) { return RespondNow(NoArguments()); } // Balanced in ClearObservers(), which is called from the first observer // method to be called with the appropriate extension (or shutdown). AddRef(); error_reporter_observation_.Observe(LoadErrorReporter::GetInstance()); registry_observation_.Observe(ExtensionRegistry::Get(browser_context())); return RespondLater(); } void DeveloperPrivateReloadFunction::OnExtensionLoaded( content::BrowserContext* browser_context, const Extension* extension) { if (extension->path() == reloading_extension_path_) { // Reload succeeded! Respond(NoArguments()); ClearObservers(); } } void DeveloperPrivateReloadFunction::OnShutdown(ExtensionRegistry* registry) { Respond(Error("Shutting down.")); ClearObservers(); } void DeveloperPrivateReloadFunction::OnLoadFailure( content::BrowserContext* browser_context, const base::FilePath& file_path, const std::u16string& error) { if (file_path == reloading_extension_path_) { // Reload failed - create an error to pass back to the extension. GetManifestError( error, file_path, base::BindOnce(&DeveloperPrivateReloadFunction::OnGotManifestError, this)); // Creates a reference. ClearObservers(); } } void DeveloperPrivateReloadFunction::OnGotManifestError( const base::FilePath& file_path, const std::u16string& error, size_t line_number, const std::string& manifest) { DeveloperPrivateAPI::UnpackedRetryId retry_guid = DeveloperPrivateAPI::Get(browser_context()) ->AddUnpackedPath(GetSenderWebContents(), reloading_extension_path_); // Respond to the caller with the load error, which allows the caller to retry // reloading through developerPrivate.loadUnpacked(). // TODO(devlin): This is weird. Really, we should allow retrying through this // function instead of through loadUnpacked(), but // ExtensionRegistrar::ReloadExtension doesn't behave well with an extension // that failed to reload, and untangling that mess is quite significant. // See https://crbug.com/41359540. Respond(WithArguments( CreateLoadError(file_path, error, line_number, manifest, retry_guid) .ToValue())); } void DeveloperPrivateReloadFunction::ClearObservers() { registry_observation_.Reset(); error_reporter_observation_.Reset(); Release(); // Balanced in Run(). } DeveloperPrivateLoadUnpackedFunction::DeveloperPrivateLoadUnpackedFunction() = default; DeveloperPrivateLoadUnpackedFunction::~DeveloperPrivateLoadUnpackedFunction() { // There may be pending file dialogs, we need to tell them that we've gone // away so they don't try and call back to us. if (select_file_dialog_.get()) { select_file_dialog_->ListenerDestroyed(); } } ExtensionFunction::ResponseAction DeveloperPrivateLoadUnpackedFunction::Run() { std::optional params = developer::LoadUnpacked::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } Profile* profile = Profile::FromBrowserContext(browser_context()); if (profile && supervised_user::AreExtensionsPermissionsEnabled(profile)) { return RespondNow( Error("Child account users cannot load unpacked extensions.")); } PrefService* prefs = profile->GetPrefs(); if (!prefs->GetBoolean(prefs::kExtensionsUIDeveloperMode)) { return RespondNow( Error("Must be in developer mode to load unpacked extensions.")); } if (ExtensionManagementFactory::GetForBrowserContext(browser_context()) ->BlocklistedByDefault()) { return RespondNow(Error("Extension installation is blocked by policy.")); } fail_quietly_ = params->options && params->options->fail_quietly && *params->options->fail_quietly; populate_error_ = params->options && params->options->populate_error && *params->options->populate_error; if (params->options && params->options->retry_guid) { DeveloperPrivateAPI* api = DeveloperPrivateAPI::Get(browser_context()); base::FilePath path = api->GetUnpackedPath(web_contents, *params->options->retry_guid); if (path.empty()) { return RespondNow(Error("Invalid retry id")); } AddRef(); // Balanced in Finish. StartFileLoad(path); return RespondLater(); } if (params->options && params->options->use_dragged_path && *params->options->use_dragged_path) { DeveloperPrivateAPI* api = DeveloperPrivateAPI::Get(browser_context()); ui::FileInfo file = api->GetDraggedFile(web_contents); if (file.path.empty()) { return RespondNow(Error("No dragged path")); } AddRef(); // Balanced in Finish. StartFileLoad(file.path); return RespondLater(); } ShowSelectFileDialog(); AddRef(); // Balanced in Finish. return RespondLater(); } void DeveloperPrivateLoadUnpackedFunction::ShowSelectFileDialog() { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); // Start or cancel the file load without showing the select file dialog for // tests that require it. if (accept_dialog_for_testing_.has_value()) { if (accept_dialog_for_testing_.value()) { CHECK(selected_file_for_testing_.has_value()); FileSelected(selected_file_for_testing_.value(), /*index=*/0); } else { FileSelectionCanceled(); } return; } content::WebContents* web_contents = GetSenderWebContents(); CHECK(web_contents); select_file_dialog_ = ui::SelectFileDialog::Create( this, std::make_unique(web_contents)); ui::SelectFileDialog::Type file_type = ui::SelectFileDialog::SELECT_EXISTING_FOLDER; std::u16string title = l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY); const base::FilePath last_directory = DeveloperPrivateAPI::Get(browser_context())->last_unpacked_directory(); auto file_type_info = ui::SelectFileDialog::FileTypeInfo(); int file_type_index = 0; gfx::NativeWindow owning_window = platform_util::GetTopLevel(web_contents->GetNativeView()); select_file_dialog_->SelectFile(file_type, title, last_directory, &file_type_info, file_type_index, base::FilePath::StringType(), owning_window); } void DeveloperPrivateLoadUnpackedFunction::FileSelected( const ui::SelectedFileInfo& file, int index) { select_file_dialog_.reset(); StartFileLoad(file.path()); } void DeveloperPrivateLoadUnpackedFunction::FileSelectionCanceled() { select_file_dialog_.reset(); // This isn't really an error, but we should keep it like this for // backward compatibility. Finish(Error(kFileSelectionCanceled)); } void DeveloperPrivateLoadUnpackedFunction::StartFileLoad( base::FilePath file_path) { #if BUILDFLAG(IS_ANDROID) // SelectFileDialog returns a content URI so on Android we need to further // resolve it to a virtual document path std::optional vp = base::ResolveToVirtualDocumentPath(file_path); if (!vp) { OnLoadComplete(nullptr, file_path, u"Failed to resolve (removed?)"); return; } file_path = *vp; #endif // BUILDFLAG(IS_ANDROID) scoped_refptr installer( UnpackedInstaller::Create(browser_context())); installer->set_be_noisy_on_failure(!fail_quietly_); installer->set_completion_callback(base::BindOnce( &DeveloperPrivateLoadUnpackedFunction::OnLoadComplete, this)); installer->Load(file_path); retry_guid_ = DeveloperPrivateAPI::Get(browser_context()) ->AddUnpackedPath(GetSenderWebContents(), file_path); } void DeveloperPrivateLoadUnpackedFunction::OnLoadComplete( const Extension* extension, const base::FilePath& file_path, const std::u16string& error) { if (extension) { Finish(NoArguments()); return; } if (!populate_error_) { Finish(Error(base::UTF16ToUTF8(error))); return; } GetManifestError( error, file_path, base::BindOnce(&DeveloperPrivateLoadUnpackedFunction::OnGotManifestError, this)); } void DeveloperPrivateLoadUnpackedFunction::OnGotManifestError( const base::FilePath& file_path, const std::u16string& error, size_t line_number, const std::string& manifest) { DCHECK(!retry_guid_.empty()); Finish(WithArguments( CreateLoadError(file_path, error, line_number, manifest, retry_guid_) .ToValue())); } void DeveloperPrivateLoadUnpackedFunction::Finish( ResponseValue response_value) { Respond(std::move(response_value)); Release(); // Balanced in Run(). } DeveloperPrivateInstallDroppedFileFunction:: DeveloperPrivateInstallDroppedFileFunction() = default; DeveloperPrivateInstallDroppedFileFunction:: ~DeveloperPrivateInstallDroppedFileFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateInstallDroppedFileFunction::Run() { content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } #if BUILDFLAG(IS_ANDROID) base::expected result = SetDroppedPath(web_contents, browser_context()); if (!result.has_value()) { return RespondNow(Error(result.error())); } #endif // BUILDFLAG(IS_ANDROID) DeveloperPrivateAPI* api = DeveloperPrivateAPI::Get(browser_context()); ui::FileInfo file = api->GetDraggedFile(web_contents); if (file.path.empty()) { return RespondNow(Error("No dragged path")); } if (MatchesExtension(file, FILE_PATH_LITERAL(".zip"))) { ExtensionRegistrar* registrar = ExtensionRegistrar::Get(browser_context()); ZipFileInstaller::Create( GetExtensionFileTaskRunner(), MakeRegisterInExtensionServiceCallback(browser_context())) ->InstallZipFileToUnpackedExtensionsDir( file.path, registrar->unpacked_install_directory()); } else { auto prompt = std::make_unique( web_contents, std::make_unique( extensions::InstallPromptData::UNSET_PROMPT_TYPE)); scoped_refptr crx_installer = CrxInstaller::Create(browser_context(), std::move(prompt)); crx_installer->set_error_on_unsupported_requirements(true); crx_installer->set_off_store_install_allow_reason( CrxInstaller::OffStoreInstallAllowedFromSettingsPage); crx_installer->set_install_immediately(true); if (MatchesExtension(file, FILE_PATH_LITERAL(".crx"))) { crx_installer->InstallCrx(file.path); } else { EXTENSION_FUNCTION_VALIDATE(false); } } // TODO(devlin): We could optionally wait to return until we validate whether // the load succeeded or failed. For now, that's unnecessary, and just adds // complexity. return RespondNow(NoArguments()); } DeveloperPrivateNotifyDragInstallInProgressFunction:: DeveloperPrivateNotifyDragInstallInProgressFunction() = default; DeveloperPrivateNotifyDragInstallInProgressFunction:: ~DeveloperPrivateNotifyDragInstallInProgressFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateNotifyDragInstallInProgressFunction::Run() { // Drop data is available only on drop on android. #if !BUILDFLAG(IS_ANDROID) content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } const base::expected result = SetDroppedPath(web_contents, browser_context()); if (!result.has_value()) { return RespondNow(Error(result.error())); } #endif // !BUILDFLAG(IS_ANDROID) return RespondNow(NoArguments()); } // static void DeveloperPrivateNotifyDragInstallInProgressFunction::SetDropFileForTesting( ui::FileInfo* file_info) { g_drop_file_for_testing = file_info; } DeveloperPrivateDeleteExtensionErrorsFunction:: ~DeveloperPrivateDeleteExtensionErrorsFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateDeleteExtensionErrorsFunction::Run() { std::optional params = developer::DeleteExtensionErrors::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const developer::DeleteExtensionErrorsProperties& properties = params->properties; ErrorConsole* error_console = ErrorConsole::Get(browser_context()); int type = -1; if (properties.type != developer::ErrorType::kNone) { type = properties.type == developer::ErrorType::kManifest ? static_cast(ExtensionError::Type::kManifestError) : static_cast(ExtensionError::Type::kRuntimeError); } std::set error_ids; if (properties.error_ids) { error_ids.insert(properties.error_ids->begin(), properties.error_ids->end()); } error_console->RemoveErrors( ErrorMap::Filter(properties.extension_id, type, error_ids, false)); return RespondNow(NoArguments()); } DeveloperPrivateShowOptionsFunction::~DeveloperPrivateShowOptionsFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateShowOptionsFunction::Run() { std::optional params = developer::ShowOptions::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetEnabledExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (OptionsPageInfo::GetOptionsPage(extension).is_empty()) { return RespondNow(Error(kNoOptionsPageForExtensionError)); } content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } ExtensionTabUtil::OpenOptionsPageFromWebContents(extension, web_contents); return RespondNow(NoArguments()); } DeveloperPrivateShowPathFunction::~DeveloperPrivateShowPathFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateShowPathFunction::Run() { std::optional params = developer::ShowPath::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } // We explicitly show manifest.json in order to work around an issue in OSX // where opening the directory doesn't focus the Finder. platform_util::ShowItemInFolder( Profile::FromBrowserContext(browser_context()), extension->path().Append(kManifestFilename)); return RespondNow(NoArguments()); } DeveloperPrivateSetShortcutHandlingSuspendedFunction:: ~DeveloperPrivateSetShortcutHandlingSuspendedFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateSetShortcutHandlingSuspendedFunction::Run() { std::optional params = developer::SetShortcutHandlingSuspended::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); ExtensionCommandsGlobalRegistry::Get(browser_context()) ->SetShortcutHandlingSuspended(params->is_suspended); return RespondNow(NoArguments()); } DeveloperPrivateUpdateExtensionCommandFunction:: ~DeveloperPrivateUpdateExtensionCommandFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateUpdateExtensionCommandFunction::Run() { std::optional params = developer::UpdateExtensionCommand::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const developer::ExtensionCommandUpdate& update = params->update; CommandService* command_service = CommandService::Get(browser_context()); if (update.scope != developer::CommandScope::kNone) { command_service->SetScope(update.extension_id, update.command_name, update.scope == developer::CommandScope::kGlobal); } if (update.keybinding) { command_service->UpdateKeybindingPrefs( update.extension_id, update.command_name, *update.keybinding); } return RespondNow(NoArguments()); } DeveloperPrivateAddHostPermissionFunction:: DeveloperPrivateAddHostPermissionFunction() = default; DeveloperPrivateAddHostPermissionFunction:: ~DeveloperPrivateAddHostPermissionFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateAddHostPermissionFunction::Run() { std::optional params = developer::AddHostPermission::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); std::optional pattern = ParseRuntimePermissionsPattern(params->host); if (!pattern) { return RespondNow(Error(kInvalidHost)); } const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (!PermissionsManager::Get(browser_context()) ->CanAffectExtension(*extension)) { return RespondNow(Error(kCannotChangeHostPermissions)); } URLPatternSet new_host_permissions({*pattern}); URLPatternSet new_host_permissions_clone = new_host_permissions.Clone(); PermissionsUpdater(browser_context()) .GrantRuntimePermissions( *extension, PermissionSet(APIPermissionSet(), ManifestPermissionSet(), std::move(new_host_permissions_clone), std::move(new_host_permissions)), base::BindOnce(&DeveloperPrivateAddHostPermissionFunction:: OnRuntimePermissionsGranted, this)); return did_respond() ? AlreadyResponded() : RespondLater(); } void DeveloperPrivateAddHostPermissionFunction::OnRuntimePermissionsGranted() { Respond(NoArguments()); } DeveloperPrivateRemoveHostPermissionFunction:: DeveloperPrivateRemoveHostPermissionFunction() = default; DeveloperPrivateRemoveHostPermissionFunction:: ~DeveloperPrivateRemoveHostPermissionFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateRemoveHostPermissionFunction::Run() { std::optional params = developer::RemoveHostPermission::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); std::optional pattern = ParseRuntimePermissionsPattern(params->host); if (!pattern) { return RespondNow(Error(kInvalidHost)); } const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } PermissionsManager* manager = PermissionsManager::Get(browser_context()); if (!manager->CanAffectExtension(*extension)) { return RespondNow(Error(kCannotChangeHostPermissions)); } URLPatternSet host_permissions_to_remove({*pattern}); URLPatternSet host_permissions_to_remove_clone = host_permissions_to_remove.Clone(); std::unique_ptr permissions_to_remove = PermissionSet::CreateIntersection( PermissionSet(APIPermissionSet(), ManifestPermissionSet(), std::move(host_permissions_to_remove_clone), std::move(host_permissions_to_remove)), *manager->GetRevokablePermissions(*extension), URLPatternSet::IntersectionBehavior::kDetailed); if (permissions_to_remove->IsEmpty()) { return RespondNow(Error("Cannot remove a host that hasn't been granted.")); } PermissionsUpdater(browser_context()) .RevokeRuntimePermissions( *extension, *permissions_to_remove, base::BindOnce(&DeveloperPrivateRemoveHostPermissionFunction:: OnRuntimePermissionsRevoked, this)); return did_respond() ? AlreadyResponded() : RespondLater(); } void DeveloperPrivateRemoveHostPermissionFunction:: OnRuntimePermissionsRevoked() { Respond(NoArguments()); } DeveloperPrivateGetUserSiteSettingsFunction:: DeveloperPrivateGetUserSiteSettingsFunction() = default; DeveloperPrivateGetUserSiteSettingsFunction:: ~DeveloperPrivateGetUserSiteSettingsFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetUserSiteSettingsFunction::Run() { developer::UserSiteSettings user_site_settings = DeveloperPrivateEventRouter::ConvertToUserSiteSettings( PermissionsManager::Get(browser_context()) ->GetUserPermissionsSettings()); return RespondNow(WithArguments(user_site_settings.ToValue())); } DeveloperPrivateAddUserSpecifiedSitesFunction:: DeveloperPrivateAddUserSpecifiedSitesFunction() = default; DeveloperPrivateAddUserSpecifiedSitesFunction:: ~DeveloperPrivateAddUserSpecifiedSitesFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateAddUserSpecifiedSitesFunction::Run() { std::optional params = developer::AddUserSpecifiedSites::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); std::set origins; for (const auto& host : params->options.hosts) { GURL url(host); if (!url.is_valid()) { return RespondNow(Error("Invalid host: " + host)); } origins.insert(url::Origin::Create(url)); } PermissionsManager* manager = PermissionsManager::Get(browser_context()); switch (params->options.site_set) { case developer::SiteSet::kUserPermitted: for (const auto& origin : origins) { manager->AddUserPermittedSite(origin); } break; case developer::SiteSet::kUserRestricted: for (const auto& origin : origins) { manager->AddUserRestrictedSite(origin); } break; case developer::SiteSet::kExtensionSpecified: return RespondNow( Error("Site set must be USER_PERMITTED or USER_RESTRICTED")); case developer::SiteSet::kNone: NOTREACHED(); } return RespondNow(NoArguments()); } DeveloperPrivateRemoveUserSpecifiedSitesFunction:: DeveloperPrivateRemoveUserSpecifiedSitesFunction() = default; DeveloperPrivateRemoveUserSpecifiedSitesFunction:: ~DeveloperPrivateRemoveUserSpecifiedSitesFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateRemoveUserSpecifiedSitesFunction::Run() { std::optional params = developer::RemoveUserSpecifiedSites::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); std::set origins; for (const auto& host : params->options.hosts) { GURL url(host); if (!url.is_valid()) { return RespondNow(Error("Invalid host: " + host)); } origins.insert(url::Origin::Create(url)); } PermissionsManager* manager = PermissionsManager::Get(browser_context()); switch (params->options.site_set) { case developer::SiteSet::kUserPermitted: for (const auto& origin : origins) { manager->RemoveUserPermittedSite(origin); } break; case developer::SiteSet::kUserRestricted: for (const auto& origin : origins) { manager->RemoveUserRestrictedSite(origin); } break; case developer::SiteSet::kExtensionSpecified: return RespondNow( Error("Site set must be USER_PERMITTED or USER_RESTRICTED")); case developer::SiteSet::kNone: NOTREACHED(); } return RespondNow(NoArguments()); } DeveloperPrivateGetUserAndExtensionSitesByEtldFunction:: DeveloperPrivateGetUserAndExtensionSitesByEtldFunction() = default; DeveloperPrivateGetUserAndExtensionSitesByEtldFunction:: ~DeveloperPrivateGetUserAndExtensionSitesByEtldFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetUserAndExtensionSitesByEtldFunction::Run() { std::map site_groups; const PermissionsManager::UserPermissionsSettings& settings = PermissionsManager::Get(browser_context())->GetUserPermissionsSettings(); for (const url::Origin& site : settings.permitted_sites) { AddSiteToSiteGroups(&site_groups, site.host(), GetETldPlusOne(site.GetURL()), developer::SiteSet::kUserPermitted); } for (const url::Origin& site : settings.restricted_sites) { AddSiteToSiteGroups(&site_groups, site.host(), GetETldPlusOne(site.GetURL()), developer::SiteSet::kUserRestricted); } std::vector> extensions_to_check; ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context()); PermissionsManager* permissions_manager = PermissionsManager::Get(browser_context()); // Note: we are only counting enabled extensions as the returned extension // counts will reflect how many extensions can actually run on each site at // the current moment. for (const auto& extension : registry->enabled_extensions()) { if (!ui_util::ShouldDisplayInExtensionSettings(*extension)) { continue; } std::unique_ptr granted_permissions = permissions_manager->GetExtensionGrantedPermissions(*extension); std::vector distinct_hosts = ExtensionInfoGenerator::GetDistinctHosts( granted_permissions->effective_hosts()); ProcessSitesForRuntimeHostPermissions(&site_groups, distinct_hosts); extensions_to_check.push_back(extension); } // Maps an eTLD+1 to the number of extensions that can run on all subdomains // of that eTLD+1. std::map match_subdomains_count; // Iterate over `site_groups` again and count the number of extensions that // can run on each site. This is in a separate loop as `site_groups` needs to // be fully populated before these checks can be made, so the num_extensions // counts are accurate. for (const auto& extension : extensions_to_check) { std::unique_ptr granted_permissions = permissions_manager->GetExtensionGrantedPermissions(*extension); UpdateSiteGroupCountsForExtensionHosts( &site_groups, &match_subdomains_count, granted_permissions->effective_hosts()); } std::vector site_group_list; site_group_list.reserve(site_groups.size()); for (auto& entry : site_groups) { // Sort the sites in each SiteGroup in ascending order by site. std::sort(entry.second.sites.begin(), entry.second.sites.end(), [](const developer::SiteInfo& a, const developer::SiteInfo& b) { return b.site > a.site; }); size_t subdomains_count_for_site = match_subdomains_count[entry.first]; if (subdomains_count_for_site > 0u) { // Append the all subdomains info to the end of the list. developer::SiteInfo all_subdomains_info = CreateSiteInfo( base::StrCat({"*.", entry.first}), developer::SiteSet::kExtensionSpecified, subdomains_count_for_site); entry.second.sites.push_back(std::move(all_subdomains_info)); } site_group_list.push_back(std::move(entry.second)); } return RespondNow( ArgumentList(developer::GetUserAndExtensionSitesByEtld::Results::Create( site_group_list))); } DeveloperPrivateGetMatchingExtensionsForSiteFunction:: DeveloperPrivateGetMatchingExtensionsForSiteFunction() = default; DeveloperPrivateGetMatchingExtensionsForSiteFunction:: ~DeveloperPrivateGetMatchingExtensionsForSiteFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateGetMatchingExtensionsForSiteFunction::Run() { std::optional params = developer::GetMatchingExtensionsForSite::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); URLPattern parsed_site(Extension::kValidHostPermissionSchemes); if (parsed_site.Parse(params->site) != URLPattern::ParseResult::kSuccess) { return RespondNow(Error("Invalid site: " + params->site)); } constexpr bool kIncludeApiPermissions = false; std::vector matching_extensions; URLPatternSet site_pattern({parsed_site}); const ExtensionSet& enabled_extensions = ExtensionRegistry::Get(browser_context())->enabled_extensions(); PermissionsManager* permissions_manager = PermissionsManager::Get(browser_context()); for (const auto& extension : enabled_extensions) { std::unique_ptr granted_permissions = permissions_manager->GetExtensionGrantedPermissions(*extension); const URLPatternSet& extension_withheld_sites = extension->permissions_data()->withheld_permissions().effective_hosts(); const URLPatternSet granted_intersection = URLPatternSet::CreateIntersection( site_pattern, granted_permissions->effective_hosts(), URLPatternSet::IntersectionBehavior::kDetailed); const URLPatternSet withheld_intersection = URLPatternSet::CreateIntersection( site_pattern, extension_withheld_sites, URLPatternSet::IntersectionBehavior::kDetailed); if (granted_intersection.is_empty() && withheld_intersection.is_empty()) { continue; } // By default, return ON_CLICK if the extension has requested but does not // have access to any sites that match `site_pattern`. developer::HostAccess host_access = developer::HostAccess::kOnClick; // TODO(crbug.com/40278776): Add a version of CanUserSelectSiteAccess to // PermissionsManager which takes in a URLPattern. bool can_request_all_sites = granted_permissions->ShouldWarnAllHosts(kIncludeApiPermissions) || extension->permissions_data() ->withheld_permissions() .ShouldWarnAllHosts(kIncludeApiPermissions); // If the extension has access to at least one site that matches // `site_pattern`, return ON_ALL_SITES if the extension can request all // sites and has no withheld sites, or ON_SPECIFIC_SITES otherwise. if (!granted_intersection.is_empty()) { host_access = can_request_all_sites && extension_withheld_sites.is_empty() ? developer::HostAccess::kOnAllSites : developer::HostAccess::kOnSpecificSites; } developer::MatchingExtensionInfo matching_info; matching_info.can_request_all_sites = can_request_all_sites; matching_info.site_access = host_access; matching_info.id = extension->id(); matching_extensions.push_back(std::move(matching_info)); } return RespondNow( ArgumentList(developer::GetMatchingExtensionsForSite::Results::Create( matching_extensions))); } DeveloperPrivateUpdateSiteAccessFunction:: DeveloperPrivateUpdateSiteAccessFunction() = default; DeveloperPrivateUpdateSiteAccessFunction:: ~DeveloperPrivateUpdateSiteAccessFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateUpdateSiteAccessFunction::Run() { std::optional params = developer::UpdateSiteAccess::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); URLPattern parsed_site(Extension::kValidHostPermissionSchemes); if (parsed_site.Parse(params->site) != URLPattern::ParseResult::kSuccess) { return RespondNow(Error("Invalid site: " + params->site)); } base::RepeatingClosure done_callback = base::BarrierClosure( params->updates.size(), base::BindOnce( &DeveloperPrivateUpdateSiteAccessFunction::OnSiteSettingsUpdated, base::RetainedRef(this))); // To ensure that this function is atomic, return with an error if any // extension specified does not exist or cannot have its host permissions // changed. PermissionsManager* const permissions_manager = PermissionsManager::Get(browser_context()); std::vector> extensions_to_modify; extensions_to_modify.reserve(params->updates.size()); for (const auto& update : params->updates) { const Extension* extension = GetExtensionById(update.id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (!permissions_manager->CanAffectExtension(*extension)) { return RespondNow(Error(kCannotChangeHostPermissions)); } extensions_to_modify.emplace_back(*extension, update.site_access); } for (const auto& update : extensions_to_modify) { const Extension& extension = update.first; std::unique_ptr permissions; ScriptingPermissionsModifier modifier(browser_context(), &extension); bool has_withheld_permissions = permissions_manager->HasWithheldHostPermissions(extension); switch (update.second) { case developer::HostAccess::kOnClick: // If the extension has no withheld permissions and can run on all of // its requested hosts, withhold all of its host permissions as a // blocklist based model for runtime host permissions (i.e. run on all // sites except these) is not currently supported. if (!has_withheld_permissions) { modifier.SetWithholdHostPermissions(true); modifier.RemoveAllGrantedHostPermissions(); done_callback.Run(); } else { modifier.RemoveHostPermissions(parsed_site, done_callback); } break; case developer::HostAccess::kOnSpecificSites: // If the extension has no withheld host permissions and can run on // all of its requested hosts, withhold all of its permissions // before granting `site`. if (!has_withheld_permissions) { modifier.SetWithholdHostPermissions(true); modifier.RemoveAllGrantedHostPermissions(); } modifier.GrantHostPermission(parsed_site, done_callback); break; case developer::HostAccess::kOnAllSites: modifier.SetWithholdHostPermissions(false); done_callback.Run(); break; case developer::HostAccess::kNone: NOTREACHED(); } } return did_respond() ? AlreadyResponded() : RespondLater(); } void DeveloperPrivateUpdateSiteAccessFunction::OnSiteSettingsUpdated() { Respond(NoArguments()); } DeveloperPrivateRemoveMultipleExtensionsFunction:: DeveloperPrivateRemoveMultipleExtensionsFunction() = default; DeveloperPrivateRemoveMultipleExtensionsFunction:: ~DeveloperPrivateRemoveMultipleExtensionsFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateRemoveMultipleExtensionsFunction::Run() { std::optional params = developer::RemoveMultipleExtensions::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); profile_ = Profile::FromBrowserContext(browser_context()); extension_ids_ = std::move(params->extension_ids); // Verify the input extension list. for (const auto& extension_id : extension_ids_) { CHECK(profile_); const Extension* current_extension = ExtensionRegistry::Get(profile_)->GetExtensionById( extension_id, ExtensionRegistry::EVERYTHING); if (!current_extension) { // Return early if the extension is a non-existent extension. return RespondNow(Error(kFailToUninstallNoneExistentExtensions)); } // If enterprise or component extensions are found, do nothing and respond // with an error. if (Manifest::IsComponentLocation(current_extension->location()) || Manifest::IsPolicyLocation(current_extension->location())) { return RespondNow(Error(kFailToUninstallEnterpriseOrComponentExtensions)); } } if (accept_bubble_for_testing_.has_value()) { if (*accept_bubble_for_testing_) { OnDialogAccepted(); } else { OnDialogCancelled(); } return AlreadyResponded(); } gfx::NativeWindow parent; if (!GetSenderWebContents()) { CHECK_IS_TEST(); parent = gfx::NativeWindow(); } else { parent = platform_util::GetTopLevel(GetSenderWebContents()->GetNativeView()); } ShowExtensionMultipleUninstallDialog( profile_, parent, extension_ids_, base::BindOnce( &DeveloperPrivateRemoveMultipleExtensionsFunction::OnDialogAccepted, this), base::BindOnce( &DeveloperPrivateRemoveMultipleExtensionsFunction::OnDialogCancelled, this)); return RespondLater(); } void DeveloperPrivateRemoveMultipleExtensionsFunction::OnDialogCancelled() { // Let the consumer end know that the Close button was clicked. Respond(Error(kUserCancelledError)); } void DeveloperPrivateRemoveMultipleExtensionsFunction::OnDialogAccepted() { for (const auto& extension_id : extension_ids_) { if (!browser_context()) { return; } const Extension* current_extension = ExtensionRegistry::Get(profile_)->GetExtensionById( extension_id, ExtensionRegistry::EVERYTHING); // Extensions can be uninstalled externally while the dialog is open. Only // uninstall extensions that are still existent. if (!current_extension) { continue; } // If an extension fails to be uninstalled, it will not pause the // uninstall of the other extensions on the list. ExtensionRegistrar::Get(profile_)->UninstallExtension( extension_id, UNINSTALL_REASON_USER_INITIATED, nullptr); } // TODO(crbug.com/463124104): Crash keys for `response_callback_` crashes. SCOPED_CRASH_KEY_BOOL("ext", "EF_DP_dialog_did_respond", did_respond()); SCOPED_CRASH_KEY_BOOL("ext", "EF_DP_dialog_resp_cb_null", response_callback_is_null()); Respond(NoArguments()); } DeveloperPrivateDismissSafetyHubExtensionsMenuNotificationFunction:: DeveloperPrivateDismissSafetyHubExtensionsMenuNotificationFunction() = default; DeveloperPrivateDismissSafetyHubExtensionsMenuNotificationFunction:: ~DeveloperPrivateDismissSafetyHubExtensionsMenuNotificationFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateDismissSafetyHubExtensionsMenuNotificationFunction::Run() { content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } Profile* profile = Profile::FromBrowserContext(browser_context()); SafetyHubMenuNotificationServiceFactory::GetForProfile(profile) ->DismissActiveNotificationOfModule( safety_hub::SafetyHubModuleType::EXTENSIONS); return RespondNow(NoArguments()); } void DeveloperPrivatePackDirectoryFunction::OnPackSuccess( const base::FilePath& crx_file, const base::FilePath& pem_file) { developer::PackDirectoryResponse response; response.message = base::UTF16ToUTF8( PackExtensionJob::StandardSuccessMessage(crx_file, pem_file)); response.status = developer::PackStatus::kSuccess; Respond(WithArguments(response.ToValue())); pack_job_.reset(); Release(); // Balanced in Run(). } void DeveloperPrivatePackDirectoryFunction::OnPackFailure( const std::u16string& error, ExtensionCreator::ErrorType error_type) { // TODO(crbug.com/41317803): Continue removing std::string errors and // replacing with std::u16string. developer::PackDirectoryResponse response; response.message = base::UTF16ToUTF8(error); if (error_type == ExtensionCreator::kCRXExists) { response.item_path = item_path_str_; response.pem_path = key_path_str_; response.override_flags = ExtensionCreator::kOverwriteCRX; response.status = developer::PackStatus::kWarning; } else { response.status = developer::PackStatus::kError; } Respond(WithArguments(response.ToValue())); pack_job_.reset(); Release(); // Balanced in Run(). } ExtensionFunction::ResponseAction DeveloperPrivatePackDirectoryFunction::Run() { std::optional params = developer_private::PackDirectory::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); int flags = params->flags ? *params->flags : 0; item_path_str_ = params->path; if (params->private_key_path) { key_path_str_ = *params->private_key_path; } base::FilePath root_directory = base::FilePath::FromUTF8Unsafe(item_path_str_); base::FilePath key_file = base::FilePath::FromUTF8Unsafe(key_path_str_); developer::PackDirectoryResponse response; #if BUILDFLAG(IS_ANDROID) // SelectFileDialog returns a content URI so on Android we need to further // resolve it to a virtual document path std::optional virtual_path = base::ResolveToVirtualDocumentPath(root_directory); if (!virtual_path) { response.message = "Failed to resolve (removed?)"; response.status = developer::PackStatus::kError; return RespondNow(WithArguments(response.ToValue())); } root_directory = *virtual_path; #endif // BUILDFLAG(IS_ANDROID) if (root_directory.empty()) { if (item_path_str_.empty()) { response.message = l10n_util::GetStringUTF8( IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_REQUIRED); } else { response.message = l10n_util::GetStringUTF8( IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_INVALID); } response.status = developer::PackStatus::kError; return RespondNow(WithArguments(response.ToValue())); } if (!key_path_str_.empty() && key_file.empty()) { response.message = l10n_util::GetStringUTF8(IDS_EXTENSION_PACK_DIALOG_ERROR_KEY_INVALID); response.status = developer::PackStatus::kError; return RespondNow(WithArguments(response.ToValue())); } AddRef(); // Balanced in OnPackSuccess / OnPackFailure. pack_job_ = std::make_unique(this, root_directory, key_file, flags); pack_job_->Start(); return RespondLater(); } DeveloperPrivatePackDirectoryFunction::DeveloperPrivatePackDirectoryFunction() = default; DeveloperPrivatePackDirectoryFunction:: ~DeveloperPrivatePackDirectoryFunction() = default; DeveloperPrivateChoosePathFunction::DeveloperPrivateChoosePathFunction() = default; DeveloperPrivateChoosePathFunction::~DeveloperPrivateChoosePathFunction() { // There may be pending file dialogs, we need to tell them that we've gone // away so they don't try and call back to us. if (select_file_dialog_.get()) { select_file_dialog_->ListenerDestroyed(); } } ExtensionFunction::ResponseAction DeveloperPrivateChoosePathFunction::Run() { std::optional params = developer::ChoosePath::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotShowSelectFileDialogError)); } // Start or cancel the file selection without showing the select file dialog // for tests that require it. if (accept_dialog_for_testing_.has_value()) { AddRef(); // Balanced in FileSelected() / FileSelectionCanceled(). if (accept_dialog_for_testing_.value()) { CHECK(selected_file_for_testing_.has_value()); FileSelected(selected_file_for_testing_.value(), /*index=*/0); } else { FileSelectionCanceled(); } CHECK(did_respond()); return AlreadyResponded(); } ui::SelectFileDialog::Type file_type = ui::SelectFileDialog::SELECT_FOLDER; ui::SelectFileDialog::FileTypeInfo file_type_info; std::u16string select_title; if (params->select_type == developer::SelectType::kFile) { file_type = ui::SelectFileDialog::SELECT_OPEN_FILE; } int file_type_index = 0; if (params->file_type == developer::FileType::kLoad) { select_title = l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY); } else if (params->file_type == developer::FileType::kPem) { select_title = l10n_util::GetStringUTF16(IDS_EXTENSION_PACK_DIALOG_SELECT_KEY); file_type_info.extensions.emplace_back(1, FILE_PATH_LITERAL("pem")); file_type_info.extension_description_overrides.push_back( l10n_util::GetStringUTF16( IDS_EXTENSION_PACK_DIALOG_KEY_FILE_TYPE_DESCRIPTION)); file_type_info.include_all_files = true; file_type_index = 1; } else { NOTREACHED(); } const base::FilePath last_directory = DeveloperPrivateAPI::Get(browser_context())->last_unpacked_directory(); gfx::NativeWindow owning_window = platform_util::GetTopLevel(web_contents->GetNativeView()); select_file_dialog_ = ui::SelectFileDialog::Create( this, std::make_unique(web_contents)); #if BUILDFLAG(IS_ANDROID) // On Android, although we are not actually writing to the file, we still need // to set this flag to trigger ACTION_OPEN_DOCUMENT intent to bypass the // file chooser dialog. select_file_dialog_->SetOpenWritable(true); #endif // BUILDFLAG(IS_ANDROID) select_file_dialog_->SelectFile(file_type, select_title, last_directory, &file_type_info, file_type_index, base::FilePath::StringType(), owning_window); AddRef(); // Balanced in FileSelected() / FileSelectionCanceled(). return RespondLater(); } void DeveloperPrivateChoosePathFunction::FileSelected( const ui::SelectedFileInfo& file, int index) { Respond(WithArguments(file.path().LossyDisplayName())); Release(); } void DeveloperPrivateChoosePathFunction::FileSelectionCanceled() { // This isn't really an error, but we should keep it like this for // backward compatability. Respond(Error(kFileSelectionCanceled)); Release(); } DeveloperPrivateRequestFileSourceFunction:: DeveloperPrivateRequestFileSourceFunction() = default; DeveloperPrivateRequestFileSourceFunction:: ~DeveloperPrivateRequestFileSourceFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateRequestFileSourceFunction::Run() { params_ = developer::RequestFileSource::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params_); const developer::RequestFileSourceProperties& properties = params_->properties; const Extension* extension = GetExtensionById(properties.extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } // Under no circumstances should we ever need to reference a file outside of // the extension's directory. If it tries to, abort. base::FilePath path_suffix = base::FilePath::FromUTF8Unsafe(properties.path_suffix); if (path_suffix.empty() || path_suffix.ReferencesParent()) { return RespondNow(Error(kInvalidPathError)); } if (properties.path_suffix == kManifestFile && !properties.manifest_key) { return RespondNow(Error(kManifestKeyIsRequiredError)); } base::ThreadPool::PostTaskAndReplyWithResult( FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE}, base::BindOnce(&ReadFileToString, extension->path().Append(path_suffix)), base::BindOnce(&DeveloperPrivateRequestFileSourceFunction::Finish, this)); return RespondLater(); } void DeveloperPrivateRequestFileSourceFunction::Finish( const std::string& file_contents) { const developer::RequestFileSourceProperties& properties = params_->properties; const Extension* extension = GetExtensionById(properties.extension_id); if (!extension) { Respond(LogNoSuchExtensionFoundAndReturn()); return; } developer::RequestFileSourceResponse response; base::FilePath path_suffix = base::FilePath::FromUTF8Unsafe(properties.path_suffix); base::FilePath path = extension->path().Append(path_suffix); response.title = base::StringPrintf("%s: %s", extension->name().c_str(), path.BaseName().AsUTF8Unsafe().c_str()); response.message = properties.message; std::unique_ptr highlighter; if (properties.path_suffix == kManifestFile) { highlighter = std::make_unique( file_contents, *properties.manifest_key, properties.manifest_specific ? *properties.manifest_specific : std::string()); } else { highlighter = std::make_unique( file_contents, properties.line_number ? *properties.line_number : 0); } developer::ErrorFileSource source; source.before_highlight = highlighter->GetBeforeFeature(); source.highlight = highlighter->GetFeature(); source.after_highlight = highlighter->GetAfterFeature(); response.source = std::move(source); Respond(WithArguments(response.ToValue())); } DeveloperPrivateOpenDevToolsFunction::DeveloperPrivateOpenDevToolsFunction() = default; DeveloperPrivateOpenDevToolsFunction::~DeveloperPrivateOpenDevToolsFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateOpenDevToolsFunction::Run() { std::optional params = developer::OpenDevTools::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const developer::OpenDevToolsProperties& properties = params->properties; Profile* profile = Profile::FromBrowserContext(browser_context()); if (properties.incognito && *properties.incognito) { profile = profile->GetPrimaryOTRProfile(/*create_if_needed=*/true); } const Extension* extension = properties.extension_id ? GetEnabledExtensionById(*properties.extension_id) : nullptr; const bool is_service_worker = properties.is_service_worker && *properties.is_service_worker; if (is_service_worker) { if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (!BackgroundInfo::IsServiceWorkerBased(extension)) { return RespondNow(Error(kInvalidLazyBackgroundPageParameter)); } if (properties.render_process_id == -1) { // Start the service worker and open the inspect window. devtools_util::InspectInactiveServiceWorkerBackground( extension, profile, DevToolsOpenedByAction::kInspectLink); return RespondNow(NoArguments()); } devtools_util::InspectServiceWorkerBackground( extension, profile, DevToolsOpenedByAction::kInspectLink); return RespondNow(NoArguments()); } if (properties.render_process_id == -1) { // This is for a lazy background page. if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (!BackgroundInfo::HasLazyBackgroundPage(extension)) { return RespondNow(Error(kInvalidRenderProcessId)); } // Wakes up the background page and opens the inspect window. devtools_util::InspectBackgroundPage(extension, profile, DevToolsOpenedByAction::kInspectLink); return RespondNow(NoArguments()); } // NOTE(devlin): Even though the properties use "render_view_id", this // actually refers to a render frame. content::RenderFrameHost* render_frame_host = content::RenderFrameHost::FromID(properties.render_process_id, properties.render_view_id); content::WebContents* web_contents = render_frame_host ? content::WebContents::FromRenderFrameHost(render_frame_host) : nullptr; // It's possible that the render frame was closed since we last updated the // links. Handle this gracefully. if (!web_contents) { return RespondNow(Error(kNoSuchRendererError)); } // If we include a url, we should inspect it specifically (and not just the // render frame). if (properties.url) { // Line/column numbers are reported in display-friendly 1-based numbers, // but are inspected in zero-based numbers. // Default to the first line/column. DevToolsWindow::OpenDevToolsWindow( web_contents, DevToolsToggleAction::Reveal( base::UTF8ToUTF16(*properties.url), properties.line_number ? *properties.line_number - 1 : 0, properties.column_number ? *properties.column_number - 1 : 0), DevToolsOpenedByAction::kInspectLink); } else { DevToolsWindow::OpenDevToolsWindow(web_contents, DevToolsOpenedByAction::kInspectLink); } #if BUILDFLAG(ENABLE_EXTENSIONS) // Once we open the inspector, we focus on the appropriate tab... BrowserWindowInterface* browser = GlobalBrowserCollection::GetInstance()->FindBrowserWithTab(web_contents); // ... but some pages (popups and apps) don't have tabs, and some (background // pages) don't have an associated browser. For these, the inspector opens in // a new window, and our work is done. if (!browser || browser->GetType() != BrowserWindowInterface::Type::TYPE_NORMAL) { return RespondNow(NoArguments()); } TabStripModel* tab_strip = browser->GetTabStripModel(); tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents( web_contents)); // Not through direct user gesture. #endif // BUILDFLAG(ENABLE_EXTENSIONS) return RespondNow(NoArguments()); } DeveloperPrivateRepairExtensionFunction:: ~DeveloperPrivateRepairExtensionFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateRepairExtensionFunction::Run() { std::optional params = developer::RepairExtension::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const Extension* extension = GetExtensionById(params->extension_id); if (!extension) { return RespondNow(LogNoSuchExtensionFoundAndReturn()); } if (!ExtensionPrefs::Get(browser_context()) ->HasDisableReason(extension->id(), disable_reason::DISABLE_CORRUPTED)) { return RespondNow(Error(kCannotRepairHealthyExtension)); } ManagementPolicy* management_policy = ExtensionSystem::Get(browser_context())->management_policy(); // If content verifier would repair this extension independently, then don't // allow repair from here. This applies to policy extensions. // Also note that if we let |reinstaller| continue with the repair, this would // have uninstalled the extension but then we would have failed to reinstall // it for policy check (see PolicyCheck::Start()). if (management_policy->ShouldRepairIfCorrupted(extension)) { return RespondNow(Error(kCannotRepairPolicyExtension)); } content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } ExtensionManagement* extension_management = ExtensionManagementFactory::GetForBrowserContext(browser_context()); if (!extension_management->UpdatesFromWebstore(*extension)) { return RespondNow(Error(kCannotRepairNonWebstoreExtension)); } auto reinstaller = base::MakeRefCounted( web_contents, params->extension_id, base::BindOnce( &DeveloperPrivateRepairExtensionFunction::OnReinstallComplete, this)); reinstaller->BeginReinstall(); return RespondLater(); } void DeveloperPrivateRepairExtensionFunction::OnReinstallComplete( bool success, const std::string& error, webstore_install::Result result) { Respond(success ? NoArguments() : Error(error)); } DeveloperPrivateUploadExtensionToAccountFunction:: DeveloperPrivateUploadExtensionToAccountFunction() = default; DeveloperPrivateUploadExtensionToAccountFunction:: ~DeveloperPrivateUploadExtensionToAccountFunction() = default; ExtensionFunction::ResponseAction DeveloperPrivateUploadExtensionToAccountFunction::Run() { auto params = developer::UploadExtensionToAccount::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); extension_id_ = std::move(params->extension_id); profile_ = Profile::FromBrowserContext(browser_context()); auto result = VerifyExtensionAndSigninState(); if (!result.has_value()) { return RespondNow(Error(result.error())); } const Extension* extension = *result; // Return an error if the extension cannot be uploaded for reasons such as: // - syncing extensions in transport mode (signed in but not full sync) is // disabled. // - the extension is already associated with the signed in user's account. // - the extension is not syncable (for example, if it's unpacked). if (!AccountExtensionTracker::Get(profile_)->CanUploadAsAccountExtension( *extension) #if BUILDFLAG(IS_CHROMEOS) || !base::FeatureList::IsEnabled(syncer::kReplaceSyncPromosWithSignInPromos) #endif ) { return RespondNow(Error(ErrorUtils::FormatErrorMessage( kCannotUploadExtensionToAccount, extension_id_))); } if (accept_bubble_for_testing_.has_value()) { if (*accept_bubble_for_testing_) { OnDialogAccepted(); } else { OnDialogCancelled(); } return AlreadyResponded(); } content::WebContents* web_contents = GetSenderWebContents(); if (!web_contents) { return RespondNow(Error(kCouldNotFindWebContentsError)); } gfx::NativeWindow parent_window = web_contents ? web_contents->GetTopLevelNativeWindow() : gfx::NativeWindow(); ShowUploadExtensionToAccountDialog( profile_, parent_window, *extension, base::BindOnce( &DeveloperPrivateUploadExtensionToAccountFunction::OnDialogAccepted, this), base::BindOnce( &DeveloperPrivateUploadExtensionToAccountFunction::OnDialogCancelled, this)); return RespondLater(); } base::expected DeveloperPrivateUploadExtensionToAccountFunction:: VerifyExtensionAndSigninState() { const Extension* extension = ExtensionRegistry::Get(browser_context()) ->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING); if (!extension) { return base::unexpected( ErrorUtils::FormatErrorMessage(kNoExtensionError, extension_id_)); } // Return an error if there is no signed in user. signin::IdentityManager* identity_manager = IdentityManagerFactory::GetForProfile(profile_); AccountInfo account_info = identity_manager->FindExtendedAccountInfo( identity_manager->GetPrimaryAccountInfo(signin::ConsentLevel::kSignin)); if (account_info.IsEmpty()) { return base::unexpected(kUserNotSignedIn); } return base::ok(extension); } void DeveloperPrivateUploadExtensionToAccountFunction::OnDialogAccepted() { // We cannot proceed if the `browser_context` is not valid as the relevant // classes needed to upload the extension will not exist. if (!browser_context()) { return; } auto result = VerifyExtensionAndSigninState(); if (!result.has_value()) { Respond(Error(result.error())); return; } const Extension* extension = *result; sync_util::UploadExtensionToAccount(profile_, *extension); Respond(WithArguments(true)); } void DeveloperPrivateUploadExtensionToAccountFunction::OnDialogCancelled() { Respond(WithArguments(false)); } #if BUILDFLAG(IS_ANDROID) DEFINE_UNIMPLEMENTED_EXTENSION_FUNCTION(DeveloperPrivateLoadDirectoryFunction, "developerPrivate.loadDirectory") ExtensionFunction::ResponseAction DeveloperPrivateShowSiteSettingsFunction::Run() { std::optional params = developer_private::ShowSiteSettings::Params::Create(args()); EXTENSION_FUNCTION_VALIDATE(params); const std::string& extension_id = params->extension_id; ExtensionDeveloperPrivateBridge::ShowSiteSettings(extension_id); return RespondNow(NoArguments()); } #else // BUILDFLAG(IS_ANDROID) ExtensionFunction::ResponseAction DeveloperPrivateLoadDirectoryFunction::Run() { // In theory `extension()` can be null when an ExtensionFunction is invoked // from WebUI, but this should never be the case for this particular API. DCHECK(extension()); // TODO(grv) : add unittests. EXTENSION_FUNCTION_VALIDATE(args().size() >= 3); EXTENSION_FUNCTION_VALIDATE(args()[0].is_string()); EXTENSION_FUNCTION_VALIDATE(args()[1].is_string()); EXTENSION_FUNCTION_VALIDATE(args()[2].is_string()); const std::string& filesystem_name = args()[0].GetString(); const std::string& filesystem_path = args()[1].GetString(); const std::string& directory_url_str = args()[2].GetString(); context_ = browser_context() ->GetStoragePartition(render_frame_host()->GetSiteInstance()) ->GetFileSystemContext(); // Directory url is non empty only for syncfilesystem. if (!directory_url_str.empty()) { storage::FileSystemURL directory_url = context_->CrackURLInFirstPartyContext(GURL(directory_url_str)); if (!directory_url.is_valid() || directory_url.type() != storage::kFileSystemTypeSyncable) { return RespondNow(Error("DirectoryEntry of unsupported filesystem.")); } return LoadByFileSystemAPI(directory_url); } std::string unused_error; // Check if the DirectoryEntry is the instance of chrome filesystem. if (!app_file_handler_util::ValidateFileEntryAndGetPath( filesystem_name, filesystem_path, source_process_id(), &project_base_path_, &unused_error)) { return RespondNow(Error("DirectoryEntry of unsupported filesystem.")); } // Try to load using the FileSystem API backend, in case the filesystem // points to a non-native local directory. std::string filesystem_id; bool cracked = storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id); CHECK(cracked); base::FilePath virtual_path = storage::IsolatedContext::GetInstance() ->CreateVirtualRootPath(filesystem_id) .Append(base::FilePath::FromUTF8Unsafe(filesystem_path)); storage::FileSystemURL directory_url = context_->CreateCrackedFileSystemURL( blink::StorageKey::CreateFirstParty(extension()->origin()), storage::kFileSystemTypeIsolated, virtual_path); if (directory_url.is_valid() && directory_url.type() != storage::kFileSystemTypeLocal && directory_url.type() != storage::kFileSystemTypeDragged) { return LoadByFileSystemAPI(directory_url); } Load(); return AlreadyResponded(); } ExtensionFunction::ResponseAction DeveloperPrivateLoadDirectoryFunction::LoadByFileSystemAPI( const storage::FileSystemURL& directory_url) { std::string directory_url_str = directory_url.ToGURL().spec(); size_t pos = 0; // Parse the project directory name from the project url. The project url is // expected to have project name as the suffix. if ((pos = directory_url_str.rfind("/")) == std::string::npos) { return RespondNow(Error("Invalid Directory entry.")); } std::string project_name; project_name = directory_url_str.substr(pos + 1); project_base_url_ = directory_url_str.substr(0, pos + 1); base::FilePath project_path(browser_context()->GetPath()); project_path = project_path.AppendASCII(kUnpackedAppsFolder); project_path = project_path.Append(base::FilePath::FromUTF8Unsafe(project_name)); project_base_path_ = project_path; base::ThreadPool::PostTask( FROM_HERE, {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}, base::BindOnce( &DeveloperPrivateLoadDirectoryFunction::ClearExistingDirectoryContent, this, project_base_path_)); return RespondLater(); } void DeveloperPrivateLoadDirectoryFunction::Load() { UnpackedInstaller::Create(browser_context())->Load(project_base_path_); // TODO(grv) : The unpacked installer should fire an event when complete // and return the extension_id. Respond(WithArguments("-1")); } void DeveloperPrivateLoadDirectoryFunction::ClearExistingDirectoryContent( const base::FilePath& project_path) { // Clear the project directory before copying new files. base::DeletePathRecursively(project_path); pending_copy_operations_count_ = 1; content::GetIOThreadTaskRunner({})->PostTask( FROM_HERE, base::BindOnce( &DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPI, this, project_path, project_path.BaseName())); } void DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPI( const base::FilePath& project_path, const base::FilePath& destination_path) { GURL project_url = GURL(project_base_url_ + destination_path.AsUTF8Unsafe()); storage::FileSystemURL url = context_->CrackURLInFirstPartyContext(project_url); context_->operation_runner()->ReadDirectory( url, base::BindRepeating(&DeveloperPrivateLoadDirectoryFunction:: ReadDirectoryByFileSystemAPICb, this, project_path, destination_path)); } void DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPICb( const base::FilePath& project_path, const base::FilePath& destination_path, base::File::Error status, storage::FileSystemOperation::FileEntryList file_list, bool has_more) { if (status != base::File::FILE_OK) { DLOG(ERROR) << "Error in copying files from sync filesystem."; return; } // We add 1 to the pending copy operations for both files and directories. We // release the directory copy operation once all the files under the directory // are added for copying. We do that to ensure that pendingCopyOperationsCount // does not become zero before all copy operations are finished. // In case the directory happens to be executing the last copy operation it // will call Respond to send the response to the API. The pending copy // operations of files are released by the CopyFile function. pending_copy_operations_count_ += file_list.size(); for (auto& file : file_list) { if (file.type == filesystem::mojom::FsFileType::DIRECTORY) { ReadDirectoryByFileSystemAPI(project_path.Append(file.name), destination_path.Append(file.name)); continue; } GURL project_url = GURL(project_base_url_ + destination_path.Append(file.name).AsUTF8Unsafe()); storage::FileSystemURL url = context_->CrackURLInFirstPartyContext(project_url); base::FilePath target_path = project_path; target_path = target_path.Append(file.name); context_->operation_runner()->CreateSnapshotFile( url, base::BindOnce( &DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback, this, target_path)); } if (!has_more) { // Directory copy operation released here. pending_copy_operations_count_--; if (!pending_copy_operations_count_) { ExtensionFunction::ResponseValue response = success_ ? NoArguments() : Error(error_); content::GetUIThreadTaskRunner({})->PostTask( FROM_HERE, base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::Respond, this, std::move(response))); } } } void DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback( const base::FilePath& target_path, base::File::Error result, const base::File::Info& file_info, const base::FilePath& src_path, scoped_refptr file_ref) { if (result != base::File::FILE_OK) { error_ = "Error in copying files from sync filesystem."; success_ = false; return; } base::ThreadPool::PostTask( FROM_HERE, {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}, base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::CopyFile, this, src_path, target_path)); } void DeveloperPrivateLoadDirectoryFunction::CopyFile( const base::FilePath& src_path, const base::FilePath& target_path) { if (!base::CreateDirectory(target_path.DirName())) { error_ = "Error in copying files from sync filesystem."; success_ = false; } if (success_) { base::CopyFile(src_path, target_path); } CHECK(pending_copy_operations_count_ > 0); pending_copy_operations_count_--; if (!pending_copy_operations_count_) { content::GetUIThreadTaskRunner({})->PostTask( FROM_HERE, base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::Load, this)); } } DeveloperPrivateLoadDirectoryFunction::DeveloperPrivateLoadDirectoryFunction() : pending_copy_operations_count_(0), success_(true) {} DeveloperPrivateLoadDirectoryFunction:: ~DeveloperPrivateLoadDirectoryFunction() {} #endif // BUILDFLAG(IS_ANDROID) } // namespace api } // namespace extensions