| // 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 "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/chrome_extension_web_contents_observer.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/installable/installable_metrics.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/components/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/render_messages.h" |
| #include "chrome/common/url_constants.h" |
| #include "components/sessions/content/session_tab_helper.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/frame_navigate_params.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_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_handlers/icons_handler.h" |
| #include "services/service_manager/public/cpp/interface_provider.h" |
| #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.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 { |
| |
| TabHelper::~TabHelper() = default; |
| |
| TabHelper::TabHelper(content::WebContents* web_contents) |
| : content::WebContentsObserver(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 ForEachFrame() is synchronous. |
| web_contents->ForEachFrame( |
| base::BindRepeating(&TabHelper::SetTabId, base::Unretained(this))); |
| active_tab_permission_granter_.reset(new 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()); |
| }); |
| |
| // We need an ExtensionWebContentsObserver, so make sure one exists (this is |
| // a no-op if one already does). |
| ChromeExtensionWebContentsObserver::CreateForWebContents(web_contents); |
| ExtensionWebContentsObserver::GetForWebContents(web_contents)->dispatcher()-> |
| set_delegate(this); |
| |
| 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()); |
| DCHECK(!extension->from_bookmark()); |
| } |
| extension_app_ = extension; |
| |
| if (extension_app_) { |
| registry_observer_.Add( |
| ExtensionRegistry::Get(web_contents()->GetBrowserContext())); |
| } else { |
| registry_observer_.RemoveAll(); |
| } |
| |
| 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_; |
| } |
| |
| // 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->IsInMainFrame()) |
| 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(); |
| |
| Browser* browser = chrome::FindBrowserWithWebContents(web_contents()); |
| if (browser && browser->deprecated_is_app()) { |
| const Extension* extension = registry->GetExtensionById( |
| web_app::GetAppIdFromApplicationName(browser->app_name()), |
| ExtensionRegistry::EVERYTHING); |
| if (extension && AppLaunchInfo::GetFullLaunchURL(extension).is_valid()) { |
| DCHECK(extension->is_app()); |
| if (!extension->from_bookmark()) |
| 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_GetAppInstallState, |
| OnGetAppInstallState) |
| 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::OnGetAppInstallState(content::RenderFrameHost* host, |
| const GURL& requestor_url, |
| int return_route_id, |
| int callback_id) { |
| ExtensionRegistry* registry = |
| ExtensionRegistry::Get(web_contents()->GetBrowserContext()); |
| const ExtensionSet& extensions = registry->enabled_extensions(); |
| const ExtensionSet& disabled_extensions = registry->disabled_extensions(); |
| |
| std::string state; |
| if (extensions.GetHostedAppByURL(requestor_url)) |
| state = extension_misc::kAppStateInstalled; |
| else if (disabled_extensions.GetHostedAppByURL(requestor_url)) |
| state = extension_misc::kAppStateDisabled; |
| else |
| state = extension_misc::kAppStateNotInstalled; |
| |
| // We use the |host| to send the message because using |
| // WebContentsObserver::Send() defaults to using the main RenderView, which |
| // might be in a different process if the request came from a frame. |
| host->Send(new ExtensionMsg_GetAppInstallStateResponse(return_route_id, state, |
| callback_id)); |
| } |
| |
| 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::OnExtensionUnloaded(content::BrowserContext* browser_context, |
| const Extension* extension, |
| UnloadedExtensionReason reason) { |
| DCHECK(extension_app_); |
| if (extension == extension_app_) |
| SetExtensionApp(nullptr); |
| } |
| |
| void TabHelper::SetTabId(content::RenderFrameHost* render_frame_host) { |
| render_frame_host->Send(new ExtensionMsg_SetTabId( |
| render_frame_host->GetRoutingID(), |
| sessions::SessionTabHelper::IdForTab(web_contents()).id())); |
| } |
| |
| WEB_CONTENTS_USER_DATA_KEY_IMPL(TabHelper) |
| |
| } // namespace extensions |