| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/extensions/tab_helper.h" |
| |
| #include <memory> |
| |
| #include "base/bind.h" |
| #include "base/check_op.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/extensions/activity_log/activity_log.h" |
| #include "chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.h" |
| #include "chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.h" |
| #include "chrome/browser/extensions/extension_action_runner.h" |
| #include "chrome/browser/extensions/extension_tab_util.h" |
| #include "chrome/browser/extensions/extension_util.h" |
| #include "chrome/browser/extensions/install_observer.h" |
| #include "chrome/browser/extensions/install_tracker.h" |
| #include "chrome/browser/extensions/install_tracker_factory.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/sessions/session_tab_helper_factory.h" |
| #include "chrome/browser/shell_integration.h" |
| #include "chrome/browser/ui/browser_commands.h" |
| #include "chrome/browser/ui/browser_dialogs.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/browser/web_applications/web_app_helpers.h" |
| #include "chrome/common/buildflags.h" |
| #include "chrome/common/extensions/extension_constants.h" |
| #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" |
| #include "chrome/common/url_constants.h" |
| #include "components/back_forward_cache/back_forward_cache_disable.h" |
| #include "components/sessions/content/session_tab_helper.h" |
| #include "content/public/browser/back_forward_cache.h" |
| #include "content/public/browser/invalidate_type.h" |
| #include "content/public/browser/navigation_controller.h" |
| #include "content/public/browser/navigation_entry.h" |
| #include "content/public/browser/navigation_handle.h" |
| #include "content/public/browser/notification_source.h" |
| #include "content/public/browser/notification_types.h" |
| #include "content/public/browser/render_frame_host.h" |
| #include "content/public/browser/render_process_host.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/content_features.h" |
| #include "extensions/browser/api/declarative/rules_registry_service.h" |
| #include "extensions/browser/api/declarative_net_request/web_contents_helper.h" |
| #include "extensions/browser/disable_reason.h" |
| #include "extensions/browser/extension_prefs.h" |
| #include "extensions/browser/extension_system.h" |
| #include "extensions/browser/extension_util.h" |
| #include "extensions/browser/extension_web_contents_observer.h" |
| #include "extensions/browser/image_loader.h" |
| #include "extensions/common/extension.h" |
| #include "extensions/common/extension_icon_set.h" |
| #include "extensions/common/extension_messages.h" |
| #include "extensions/common/extension_resource.h" |
| #include "extensions/common/extension_urls.h" |
| #include "extensions/common/feature_switch.h" |
| #include "extensions/common/manifest.h" |
| #include "extensions/common/manifest_handlers/icons_handler.h" |
| #include "extensions/common/permissions/api_permission.h" |
| #include "services/service_manager/public/cpp/interface_provider.h" |
| #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h" |
| #include "third_party/blink/public/common/features.h" |
| #include "url/url_constants.h" |
| |
| #if BUILDFLAG(ENABLE_SESSION_SERVICE) |
| #include "chrome/browser/sessions/session_service.h" |
| #include "chrome/browser/sessions/session_service_factory.h" |
| #endif |
| |
| using content::NavigationController; |
| using content::NavigationEntry; |
| using content::WebContents; |
| |
| namespace extensions { |
| |
| const char kIsPrerender2DisabledKey[] = "extensions.prerender2.browsercontext"; |
| |
| namespace { |
| |
| bool AreAllExtensionsAllowedForBFCache() { |
| static base::FeatureParam<bool> all_extensions_allowed( |
| &features::kBackForwardCache, "all_extensions_allowed", true); |
| return all_extensions_allowed.Get(); |
| } |
| |
| std::string BlockedExtensionListForBFCache() { |
| static base::FeatureParam<std::string> extensions_blocked( |
| &features::kBackForwardCache, "blocked_extensions", ""); |
| return extensions_blocked.Get(); |
| } |
| |
| bool AreAllExtensionsAllowedForPrerender2(content::WebContents* web_contents) { |
| static base::FeatureParam<bool> all_extensions_allowed( |
| &blink::features::kPrerender2, "all_extensions_allowed", true); |
| return all_extensions_allowed.Get(); |
| } |
| |
| std::string BlockedExtensionListForPrerender2( |
| content::WebContents* web_contents) { |
| static base::FeatureParam<std::string> extensions_blocked( |
| &blink::features::kPrerender2, "blocked_extensions", ""); |
| return extensions_blocked.Get(); |
| } |
| |
| // Check `enabled_extensions` if any of them are specified in the |
| // `blocked_extensions` or not. |
| bool ProcessDisabledExtensions(const std::string& feature, |
| const ExtensionSet& enabled_extensions, |
| content::BrowserContext* context, |
| bool all_allowed, |
| const std::string& blocked_extensions) { |
| // If we allow all extensions and there aren't any blocked, then just return. |
| if (all_allowed && blocked_extensions.empty()) |
| return false; |
| |
| std::vector<std::string> blocked_extensions_list = |
| base::SplitString(blocked_extensions, ",", base::TRIM_WHITESPACE, |
| base::SPLIT_WANT_NONEMPTY); |
| |
| // Compute whether we need to disable it. |
| bool disabled_feature = false; |
| for (const auto& extension : enabled_extensions) { |
| // Skip component extensions, apps, themes, shared modules and the google |
| // docs pre-installed extension. |
| if (Manifest::IsComponentLocation(extension->location()) || |
| extension->is_app() || extension->is_theme() || |
| extension->is_shared_module() || |
| extension->id() == extension_misc::kDocsOfflineExtensionId) { |
| continue; |
| } |
| if (util::IsExtensionVisibleToContext(*extension, context)) { |
| // If we are allowing all extensions with a block filter set, and this |
| // extension is not in it then continue. |
| if (all_allowed && |
| !base::Contains(blocked_extensions_list, extension->id())) { |
| continue; |
| } |
| |
| VLOG(1) << "Disabled " << feature << " due to " << extension->short_name() |
| << "," << extension->id(); |
| disabled_feature = true; |
| // TODO(dtapuska): Early termination disabled for now to capture VLOG(1) |
| // break; |
| } |
| } |
| |
| return disabled_feature; |
| } |
| |
| void DisableBackForwardCacheIfNecessary( |
| const ExtensionSet& enabled_extensions, |
| content::BrowserContext* context, |
| content::NavigationHandle* navigation_handle) { |
| // User data key for caching if bfcache is disabled. |
| static const char kIsBFCacheDisabledKey[] = |
| "extensions.backforward.browsercontext"; |
| |
| if (!content::BackForwardCache::IsBackForwardCacheFeatureEnabled() || |
| context->GetUserData(kIsBFCacheDisabledKey)) { |
| return; |
| } |
| |
| if (ProcessDisabledExtensions("bfcache", enabled_extensions, context, |
| AreAllExtensionsAllowedForBFCache(), |
| BlockedExtensionListForBFCache())) { |
| // Set a user data key indicating we've disabled bfcache for this |
| // context. |
| context->SetUserData(kIsBFCacheDisabledKey, |
| std::make_unique<base::SupportsUserData::Data>()); |
| |
| // We do not care if GetPreviousRenderFrameHostId returns a reused |
| // RenderFrameHost since disabling the cache multiple times has no side |
| // effects. |
| content::BackForwardCache::DisableForRenderFrameHost( |
| navigation_handle->GetPreviousRenderFrameHostId(), |
| back_forward_cache::DisabledReason( |
| back_forward_cache::DisabledReasonId::kExtensions)); |
| } |
| } |
| |
| // TODO(https://crbug.com/1344511): Current code is overly complex and circular; |
| // TabHelper sets a bit on the WebContents so that the WebContents can call into |
| // the Browser so that the Browser can check the bit that was set by TabHelper. |
| // Instead, 1) Having extensions code directly disable Prerender2 on a |
| // WebContents (just expose a DisablePrerender2 method), or 2) Having the |
| // browser code just ask extensions if Prerender2 should be enabled (and |
| // avoiding setting any bit on the WebContents). |
| // See also Devlin's comment on patchset 10 at https://crrev.com/c/3762942. |
| void UpdatePrerender2DisabledKey(const ExtensionSet& enabled_extensions, |
| content::WebContents* web_contents) { |
| if (ProcessDisabledExtensions( |
| "prerender2", enabled_extensions, web_contents->GetBrowserContext(), |
| AreAllExtensionsAllowedForPrerender2(web_contents), |
| BlockedExtensionListForPrerender2(web_contents))) { |
| web_contents->GetBrowserContext()->SetUserData( |
| kIsPrerender2DisabledKey, |
| std::make_unique<base::SupportsUserData::Data>()); |
| } else { |
| web_contents->GetBrowserContext()->RemoveUserData(kIsPrerender2DisabledKey); |
| } |
| } |
| |
| } // namespace |
| |
| TabHelper::~TabHelper() = default; |
| |
| TabHelper::TabHelper(content::WebContents* web_contents) |
| : content::WebContentsObserver(web_contents), |
| content::WebContentsUserData<TabHelper>(*web_contents), |
| profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())), |
| extension_app_(nullptr), |
| script_executor_(new ScriptExecutor(web_contents)), |
| extension_action_runner_(new ExtensionActionRunner(web_contents)), |
| declarative_net_request_helper_(web_contents) { |
| // The ActiveTabPermissionManager requires a session ID; ensure this |
| // WebContents has one. |
| CreateSessionServiceTabHelper(web_contents); |
| // The Unretained() is safe because ForEachRenderFrameHost() is synchronous. |
| web_contents->ForEachRenderFrameHost( |
| base::BindRepeating(&TabHelper::SetTabId, base::Unretained(this))); |
| active_tab_permission_granter_ = std::make_unique<ActiveTabPermissionGranter>( |
| web_contents, sessions::SessionTabHelper::IdForTab(web_contents).id(), |
| profile_); |
| |
| ActivityLog::GetInstance(profile_)->ObserveScripts(script_executor_.get()); |
| |
| InvokeForContentRulesRegistries([this](ContentRulesRegistry* registry) { |
| registry->MonitorWebContentsForRuleEvaluation(this->web_contents()); |
| }); |
| |
| ExtensionWebContentsObserver::GetForWebContents(web_contents)->dispatcher()-> |
| set_delegate(this); |
| |
| registry_observation_.Observe( |
| ExtensionRegistry::Get(web_contents->GetBrowserContext())); |
| |
| BookmarkManagerPrivateDragEventRouter::CreateForWebContents(web_contents); |
| } |
| |
| void TabHelper::SetExtensionApp(const Extension* extension) { |
| DCHECK(!extension || AppLaunchInfo::GetFullLaunchURL(extension).is_valid()); |
| if (extension_app_ == extension) |
| return; |
| |
| if (extension) { |
| DCHECK(extension->is_app()); |
| } |
| extension_app_ = extension; |
| |
| UpdateExtensionAppIcon(extension_app_); |
| |
| #if BUILDFLAG(ENABLE_SESSION_SERVICE) |
| if (extension_app_) { |
| SessionService* session_service = SessionServiceFactory::GetForProfile( |
| Profile::FromBrowserContext(web_contents()->GetBrowserContext())); |
| if (session_service) { |
| sessions::SessionTabHelper* session_tab_helper = |
| sessions::SessionTabHelper::FromWebContents(web_contents()); |
| session_service->SetTabExtensionAppID(session_tab_helper->window_id(), |
| session_tab_helper->session_id(), |
| GetExtensionAppId()); |
| } |
| } |
| #endif |
| } |
| |
| void TabHelper::SetExtensionAppById(const ExtensionId& extension_app_id) { |
| const Extension* extension = GetExtension(extension_app_id); |
| if (extension) |
| SetExtensionApp(extension); |
| } |
| |
| ExtensionId TabHelper::GetExtensionAppId() const { |
| return extension_app_ ? extension_app_->id() : ExtensionId(); |
| } |
| |
| SkBitmap* TabHelper::GetExtensionAppIcon() { |
| if (extension_app_icon_.empty()) |
| return nullptr; |
| |
| return &extension_app_icon_; |
| } |
| |
| void TabHelper::OnWatchedPageChanged( |
| const std::vector<std::string>& css_selectors) { |
| InvokeForContentRulesRegistries( |
| [this, css_selectors](ContentRulesRegistry* registry) { |
| registry->OnWatchedPageChanged(web_contents(), css_selectors); |
| }); |
| } |
| |
| // Encapsulates the logic to decide which ContentRulesRegistries need to be |
| // invoked, depending on whether this WebContents is associated with an Original |
| // or OffTheRecord profile. In the latter case, we need to invoke on both the |
| // Original and OffTheRecord ContentRulesRegistries since the Original registry |
| // handles spanning-mode incognito extensions. |
| template <class Func> |
| void TabHelper::InvokeForContentRulesRegistries(const Func& func) { |
| RulesRegistryService* rules_registry_service = |
| RulesRegistryService::Get(profile_); |
| if (rules_registry_service) { |
| func(rules_registry_service->content_rules_registry()); |
| if (profile_->IsOffTheRecord()) { |
| // The original profile's content rules registry handles rules for |
| // spanning extensions in incognito profiles, so invoke it also. |
| RulesRegistryService* original_profile_rules_registry_service = |
| RulesRegistryService::Get(profile_->GetOriginalProfile()); |
| DCHECK_NE(rules_registry_service, |
| original_profile_rules_registry_service); |
| if (original_profile_rules_registry_service) |
| func(original_profile_rules_registry_service->content_rules_registry()); |
| } |
| } |
| } |
| |
| void TabHelper::RenderFrameCreated(content::RenderFrameHost* host) { |
| SetTabId(host); |
| } |
| |
| void TabHelper::DidFinishNavigation( |
| content::NavigationHandle* navigation_handle) { |
| if (!navigation_handle->HasCommitted() || |
| !navigation_handle->IsInPrimaryMainFrame()) |
| return; |
| |
| InvokeForContentRulesRegistries( |
| [this, navigation_handle](ContentRulesRegistry* registry) { |
| registry->DidFinishNavigation(web_contents(), navigation_handle); |
| }); |
| |
| content::BrowserContext* context = web_contents()->GetBrowserContext(); |
| ExtensionRegistry* registry = ExtensionRegistry::Get(context); |
| const ExtensionSet& enabled_extensions = registry->enabled_extensions(); |
| |
| DisableBackForwardCacheIfNecessary(enabled_extensions, context, |
| navigation_handle); |
| |
| Browser* browser = chrome::FindBrowserWithWebContents(web_contents()); |
| if (browser && (browser->is_type_app() || browser->is_type_app_popup())) { |
| const Extension* extension = registry->GetInstalledExtension( |
| web_app::GetAppIdFromApplicationName(browser->app_name())); |
| if (extension && AppLaunchInfo::GetFullLaunchURL(extension).is_valid()) { |
| DCHECK(extension->is_app()); |
| SetExtensionApp(extension); |
| } |
| } else { |
| UpdateExtensionAppIcon( |
| enabled_extensions.GetExtensionOrAppByURL(navigation_handle->GetURL())); |
| } |
| } |
| |
| bool TabHelper::OnMessageReceived(const IPC::Message& message, |
| content::RenderFrameHost* sender) { |
| bool handled = true; |
| IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(TabHelper, message, sender) |
| IPC_MESSAGE_HANDLER(ExtensionHostMsg_ContentScriptsExecuting, |
| OnContentScriptsExecuting) |
| IPC_MESSAGE_UNHANDLED(handled = false) |
| IPC_END_MESSAGE_MAP() |
| return handled; |
| } |
| |
| void TabHelper::DidCloneToNewWebContents(WebContents* old_web_contents, |
| WebContents* new_web_contents) { |
| // When the WebContents that this is attached to is cloned, give the new clone |
| // a TabHelper and copy state over. |
| CreateForWebContents(new_web_contents); |
| TabHelper* new_helper = FromWebContents(new_web_contents); |
| |
| new_helper->SetExtensionApp(extension_app_); |
| new_helper->extension_app_icon_ = extension_app_icon_; |
| } |
| |
| void TabHelper::WebContentsDestroyed() { |
| InvokeForContentRulesRegistries([this](ContentRulesRegistry* registry) { |
| registry->WebContentsDestroyed(web_contents()); |
| }); |
| } |
| |
| void TabHelper::OnContentScriptsExecuting( |
| content::RenderFrameHost* host, |
| const ExecutingScriptsMap& executing_scripts_map, |
| const GURL& on_url) { |
| ActivityLog::GetInstance(profile_)->OnScriptsExecuted( |
| web_contents(), executing_scripts_map, on_url); |
| } |
| |
| const Extension* TabHelper::GetExtension(const ExtensionId& extension_app_id) { |
| if (extension_app_id.empty()) |
| return NULL; |
| |
| content::BrowserContext* context = web_contents()->GetBrowserContext(); |
| return ExtensionRegistry::Get(context)->enabled_extensions().GetByID( |
| extension_app_id); |
| } |
| |
| void TabHelper::UpdateExtensionAppIcon(const Extension* extension) { |
| extension_app_icon_.reset(); |
| // Ensure previously enqueued callbacks are ignored. |
| image_loader_ptr_factory_.InvalidateWeakPtrs(); |
| |
| // Enqueue OnImageLoaded callback. |
| if (extension) { |
| ImageLoader* loader = ImageLoader::Get(profile_); |
| loader->LoadImageAsync( |
| extension, |
| IconsInfo::GetIconResource(extension, |
| extension_misc::EXTENSION_ICON_SMALL, |
| ExtensionIconSet::MATCH_BIGGER), |
| gfx::Size(extension_misc::EXTENSION_ICON_SMALL, |
| extension_misc::EXTENSION_ICON_SMALL), |
| base::BindOnce(&TabHelper::OnImageLoaded, |
| image_loader_ptr_factory_.GetWeakPtr())); |
| } |
| } |
| |
| void TabHelper::OnImageLoaded(const gfx::Image& image) { |
| if (!image.IsEmpty()) { |
| extension_app_icon_ = *image.ToSkBitmap(); |
| web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB); |
| } |
| } |
| |
| WindowController* TabHelper::GetExtensionWindowController() const { |
| return ExtensionTabUtil::GetWindowControllerOfTab(web_contents()); |
| } |
| |
| WebContents* TabHelper::GetAssociatedWebContents() const { |
| return web_contents(); |
| } |
| |
| void TabHelper::OnExtensionLoaded(content::BrowserContext* browser_context, |
| const Extension* extension) { |
| // Clear the back forward cache for the associated tab to accommodate for any |
| // side effects of loading/unloading the extension. |
| web_contents()->GetController().GetBackForwardCache().Flush(); |
| |
| // Update a setting to disable Prerender2 based on loaded Extensions. |
| UpdatePrerender2DisabledKey( |
| ExtensionRegistry::Get(browser_context)->enabled_extensions(), |
| web_contents()); |
| } |
| |
| void TabHelper::OnExtensionUnloaded(content::BrowserContext* browser_context, |
| const Extension* extension, |
| UnloadedExtensionReason reason) { |
| // Clear the back forward cache for the associated tab to accommodate for any |
| // side effects of loading/unloading the extension. |
| web_contents()->GetController().GetBackForwardCache().Flush(); |
| |
| // Update a setting to disable Prerender2 based on loaded Extensions. |
| UpdatePrerender2DisabledKey( |
| ExtensionRegistry::Get(browser_context)->enabled_extensions(), |
| web_contents()); |
| |
| if (!extension_app_) |
| return; |
| if (extension == extension_app_) |
| SetExtensionApp(nullptr); |
| } |
| |
| void TabHelper::SetTabId(content::RenderFrameHost* render_frame_host) { |
| // When this is called from the TabHelper constructor during WebContents |
| // creation, the renderer-side Frame object would not have been created yet. |
| // We should wait for RenderFrameCreated() to happen, to avoid sending this |
| // message twice. |
| if (render_frame_host->IsRenderFrameLive()) { |
| SessionID id = sessions::SessionTabHelper::IdForTab(web_contents()); |
| CHECK(id.is_valid()); |
| ExtensionWebContentsObserver::GetForWebContents(web_contents()) |
| ->GetLocalFrame(render_frame_host) |
| ->SetTabId(id.id()); |
| } |
| } |
| |
| WEB_CONTENTS_USER_DATA_KEY_IMPL(TabHelper); |
| |
| } // namespace extensions |