bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove explicit tracking of guest view frames

Browse Source 
This is no longer required now that we have implicit exclusion
of certain frame types including guest view frames.

Rename GuestView to ExcludedView in the renderer process.
This commit is contained in:
Marshall Greenblatt
2024-04-24 17:23:47 -04:00
parent 65234a6830
commit 5065aba1b4
27 changed files with 166 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
libcef/browser/alloy/alloy_browser_host_impl.cc
View File

@ -16,6 +16,7 @@
#include "libcef/browser/browser_info_manager.h"
#include "libcef/browser/browser_platform_delegate.h"
#include "libcef/browser/context.h"
#include "libcef/browser/extensions/browser_extensions_util.h"
#include "libcef/browser/hang_monitor.h"
#include "libcef/browser/media_access_query.h"
#include "libcef/browser/osr/osr_util.h"
@ -604,9 +605,8 @@ void AlloyBrowserHostImpl::CancelContextMenu() {
bool AlloyBrowserHostImpl::MaybeAllowNavigation(
content::RenderFrameHost* opener,
const content::OpenURLParams& params) {
bool is_guest_view = false;
GetFrameForHost(opener, &is_guest_view);
const bool is_guest_view = extensions::IsBrowserPluginGuest(
content::WebContents::FromRenderFrameHost(opener));
if (is_guest_view && !params.is_pdf &&
!params.url.SchemeIs(extensions::kExtensionScheme) &&
!params.url.SchemeIs(content::kChromeUIScheme)) {

5
libcef/browser/browser_contents_delegate.cc
View File

@ -94,8 +94,7 @@ void CefBrowserContentsDelegate::ObserveWebContents(
// Make sure MaybeCreateFrame is called at least one time.
// Create the frame representation before OnAfterCreated is called for a new
// browser.
browser_info_->MaybeCreateFrame(new_contents->GetPrimaryMainFrame(),
false /* is_guest_view */);
browser_info_->MaybeCreateFrame(new_contents->GetPrimaryMainFrame());
// Make sure RenderWidgetCreated is called at least one time. This Observer
// is registered too late to catch the initial creation.
@ -319,7 +318,7 @@ void CefBrowserContentsDelegate::DraggableRegionsChanged(
void CefBrowserContentsDelegate::RenderFrameCreated(
content::RenderFrameHost* render_frame_host) {
browser_info_->MaybeCreateFrame(render_frame_host, false /* is_guest_view */);
browser_info_->MaybeCreateFrame(render_frame_host);
if (render_frame_host->GetParent() == nullptr) {
auto render_view_host = render_frame_host->GetRenderViewHost();
auto base_background_color = platform_delegate()->GetBackgroundColor();

6
libcef/browser/browser_context.cc
View File

@ -283,8 +283,7 @@ std::vector<CefBrowserContext*> CefBrowserContext::GetAll() {
void CefBrowserContext::OnRenderFrameCreated(
CefRequestContextImpl* request_context,
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view) {
bool is_main_frame) {
CEF_REQUIRE_UIT();
DCHECK(frame_util::IsValidGlobalId(global_id));
@ -302,8 +301,7 @@ void CefBrowserContext::OnRenderFrameCreated(
void CefBrowserContext::OnRenderFrameDeleted(
CefRequestContextImpl* request_context,
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view) {
bool is_main_frame) {
CEF_REQUIRE_UIT();
DCHECK(frame_util::IsValidGlobalId(global_id));

6
libcef/browser/browser_context.h
View File

@ -132,14 +132,12 @@ class CefBrowserContext {
// Called from CefRequestContextImpl::OnRenderFrameCreated.
void OnRenderFrameCreated(CefRequestContextImpl* request_context,
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view);
bool is_main_frame);
// Called from CefRequestContextImpl::OnRenderFrameDeleted.
void OnRenderFrameDeleted(CefRequestContextImpl* request_context,
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view);
bool is_main_frame);
// Returns the handler that matches the specified IDs. Pass -1 for unknown
// values. If |require_frame_match| is true only exact matches will be

10
libcef/browser/browser_frame.cc
View File

@ -59,10 +59,10 @@ void CefBrowserFrame::FrameAttached(
bool reattached) {
// Always send to the newly created RFH, which may be speculative when
// navigating cross-origin.
bool excluded_type;
if (auto host = GetFrameHost(/*prefer_speculative=*/true, &excluded_type)) {
bool is_excluded;
if (auto host = GetFrameHost(/*prefer_speculative=*/true, &is_excluded)) {
host->FrameAttached(std::move(render_frame), reattached);
} else if (excluded_type) {
} else if (is_excluded) {
VLOG(1) << "frame "
<< frame_util::GetFrameDebugString(
render_frame_host()->GetGlobalFrameToken())
@ -82,8 +82,8 @@ void CefBrowserFrame::UpdateDraggableRegions(
CefRefPtr<CefFrameHostImpl> CefBrowserFrame::GetFrameHost(
bool prefer_speculative,
bool* excluded_type) const {
bool* is_excluded) const {
return CefBrowserInfoManager::GetFrameHost(
render_frame_host(), prefer_speculative,
/*browser_info=*/nullptr, excluded_type);
/*browser_info=*/nullptr, is_excluded);
}

2
libcef/browser/browser_frame.h
View File

@ -49,7 +49,7 @@ class CefBrowserFrame
bool ShouldCloseOnFinishNavigation() const override { return false; }
CefRefPtr<CefFrameHostImpl> GetFrameHost(bool prefer_speculative,
bool* excluded_type = nullptr) const;
bool* is_excluded = nullptr) const;
};
#endif // CEF_LIBCEF_BROWSER_BROWSER_FRAME_H_

22
libcef/browser/browser_host_base.cc
View File

@ -126,9 +126,9 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForContents(
return browser;
}
// Try the owner WebContents if |contents| originates from a guest view such
// as the PDF viewer or Print Preview.
// This is safe to call even if Alloy extensions are disabled.
// Try the owner WebContents if |contents| originates from an excluded view
// such as the PDF viewer or Print Preview. This is safe to call even if Alloy
// extensions are disabled.
if (auto* owner_contents = extensions::GetOwnerForGuestContents(contents)) {
return WebContentsUserDataAdapter::Get(owner_contents);
}
@ -153,8 +153,7 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForGlobalId(
return GetBrowserForHost(render_frame_host);
} else {
// Use the thread-safe approach.
auto info = CefBrowserInfoManager::GetInstance()->GetBrowserInfo(global_id,
nullptr);
auto info = CefBrowserInfoManager::GetInstance()->GetBrowserInfo(global_id);
if (info) {
auto browser = info->browser();
if (!browser) {
@ -185,8 +184,8 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForGlobalToken(
return GetBrowserForHost(render_frame_host);
} else {
// Use the thread-safe approach.
auto info = CefBrowserInfoManager::GetInstance()->GetBrowserInfo(
global_token, nullptr);
auto info =
CefBrowserInfoManager::GetInstance()->GetBrowserInfo(global_token);
if (info) {
auto browser = info->browser();
if (!browser) {
@ -1121,24 +1120,23 @@ void CefBrowserHostBase::OnWebContentsDestroyed(
content::WebContents* web_contents) {}
CefRefPtr<CefFrame> CefBrowserHostBase::GetFrameForHost(
const content::RenderFrameHost* host,
bool* is_guest_view) {
const content::RenderFrameHost* host) {
CEF_REQUIRE_UIT();
if (!host) {
return nullptr;
}
return browser_info_->GetFrameForHost(host, is_guest_view);
return browser_info_->GetFrameForHost(host);
}
CefRefPtr<CefFrame> CefBrowserHostBase::GetFrameForGlobalId(
const content::GlobalRenderFrameHostId& global_id) {
return browser_info_->GetFrameForGlobalId(global_id, nullptr);
return browser_info_->GetFrameForGlobalId(global_id);
}
CefRefPtr<CefFrame> CefBrowserHostBase::GetFrameForGlobalToken(
const content::GlobalRenderFrameHostToken& global_token) {
return browser_info_->GetFrameForGlobalToken(global_token, nullptr);
return browser_info_->GetFrameForGlobalToken(global_token);
}
void CefBrowserHostBase::AddObserver(Observer* observer) {

8
libcef/browser/browser_host_base.h
View File

@ -286,12 +286,8 @@ class CefBrowserHostBase : public CefBrowserHost,
void OnWebContentsDestroyed(content::WebContents* web_contents) override;
// Returns the frame object matching the specified |host| or nullptr if no
// match is found. Nullptr will also be returned if a guest view match is
// found because we don't create frame objects for guest views. If
// |is_guest_view| is non-nullptr it will be set to true in this case. Must be
// called on the UI thread.
CefRefPtr<CefFrame> GetFrameForHost(const content::RenderFrameHost* host,
bool* is_guest_view = nullptr);
// match is found. Must be called on the UI thread.
CefRefPtr<CefFrame> GetFrameForHost(const content::RenderFrameHost* host);
// Returns the frame associated with the specified global ID/token. See
// documentation on RenderFrameHost::GetFrameTreeNodeId/Token() for why the

43
libcef/browser/browser_info.cc
View File

@ -95,8 +95,7 @@ void CefBrowserInfo::SetClosing() {
is_closing_ = true;
}
void CefBrowserInfo::MaybeCreateFrame(content::RenderFrameHost* host,
bool is_guest_view) {
void CefBrowserInfo::MaybeCreateFrame(content::RenderFrameHost* host) {
CEF_REQUIRE_UIT();
if (CefBrowserInfoManager::IsExcludedFrameHost(host)) {
@ -129,11 +128,10 @@ void CefBrowserInfo::MaybeCreateFrame(content::RenderFrameHost* host,
#if DCHECK_IS_ON()
// Check that the frame info hasn't changed unexpectedly.
DCHECK_EQ(info->global_id_, global_id);
DCHECK_EQ(info->is_guest_view_, is_guest_view);
DCHECK_EQ(info->is_main_frame_, is_main_frame);
#endif
if (!info->is_guest_view_ && info->is_speculative_ && !is_speculative) {
if (info->is_speculative_ && !is_speculative) {
// Upgrade the frame info from speculative to non-speculative.
if (info->is_main_frame_) {
// Set the main frame object.
@ -147,12 +145,9 @@ void CefBrowserInfo::MaybeCreateFrame(content::RenderFrameHost* host,
auto frame_info = new FrameInfo;
frame_info->host_ = host;
frame_info->global_id_ = global_id;
frame_info->is_guest_view_ = is_guest_view;
frame_info->is_main_frame_ = is_main_frame;
frame_info->is_speculative_ = is_speculative;
// Guest views don't get their own CefBrowser or CefFrame objects.
if (!is_guest_view) {
// Create a new frame object.
frame_info->frame_ = new CefFrameHostImpl(this, host);
MaybeNotifyFrameCreated(frame_info->frame_);
@ -165,10 +160,8 @@ void CefBrowserInfo::MaybeCreateFrame(content::RenderFrameHost* host,
DCHECK(host->GetGlobalFrameToken() == *frame_info->frame_->frame_token());
DCHECK_EQ(frame_info->is_main_frame_, frame_info->frame_->IsMain());
#endif
}
browser_->request_context()->OnRenderFrameCreated(global_id, is_main_frame,
is_guest_view);
browser_->request_context()->OnRenderFrameCreated(global_id, is_main_frame);
// Populate the lookup maps.
frame_id_map_.insert(std::make_pair(global_id, frame_info));
@ -238,8 +231,8 @@ void CefBrowserInfo::RemoveFrame(content::RenderFrameHost* host) {
auto frame_info = it->second;
browser_->request_context()->OnRenderFrameDeleted(
global_id, frame_info->is_main_frame_, frame_info->is_guest_view_);
browser_->request_context()->OnRenderFrameDeleted(global_id,
frame_info->is_main_frame_);
// Remove from the lookup maps.
frame_id_map_.erase(it);
@ -290,29 +283,19 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::CreateTempSubFrame(
CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForHost(
const content::RenderFrameHost* host,
bool* is_guest_view,
bool prefer_speculative) const {
if (is_guest_view) {
*is_guest_view = false;
}
if (!host) {
return nullptr;
}
return GetFrameForGlobalId(
const_cast<content::RenderFrameHost*>(host)->GetGlobalId(), is_guest_view,
const_cast<content::RenderFrameHost*>(host)->GetGlobalId(),
prefer_speculative);
}
CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalId(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view,
bool prefer_speculative) const {
if (is_guest_view) {
*is_guest_view = false;
}
if (!frame_util::IsValidGlobalId(global_id)) {
return nullptr;
}
@ -323,13 +306,6 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalId(
if (it != frame_id_map_.end()) {
const auto info = it->second;
if (info->is_guest_view_) {
if (is_guest_view) {
*is_guest_view = true;
}
return nullptr;
}
if (info->is_speculative_ && !prefer_speculative) {
if (info->is_main_frame_ && main_frame_) {
// Always prefer the non-speculative main frame.
@ -349,12 +325,7 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalId(
CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalToken(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view,
bool prefer_speculative) const {
if (is_guest_view) {
*is_guest_view = false;
}
if (!frame_util::IsValidGlobalToken(global_token)) {
return nullptr;
}
@ -370,7 +341,7 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalToken(
global_id = it->second;
}
return GetFrameForGlobalId(global_id, is_guest_view, prefer_speculative);
return GetFrameForGlobalId(global_id, prefer_speculative);
}
CefBrowserInfo::FrameHostList CefBrowserInfo::GetAllFrames() const {

25
libcef/browser/browser_info.h
View File

@ -67,10 +67,8 @@ class CefBrowserInfo : public base::RefCountedThreadSafe<CefBrowserInfo> {
// Ensure that a frame record exists for |host|. Called for the main frame
// when the RenderView is created, or for a sub-frame when the associated
// RenderFrame is created in the renderer process.
// Called from CefBrowserContentsDelegate::RenderFrameCreated (is_guest_view =
// false) or CefMimeHandlerViewGuestDelegate::OnGuestAttached (is_guest_view =
// true).
void MaybeCreateFrame(content::RenderFrameHost* host, bool is_guest_view);
// Called from CefBrowserContentsDelegate::RenderFrameCreated.
void MaybeCreateFrame(content::RenderFrameHost* host);
// Used to track state changes such as entering/exiting the BackForwardCache.
// Called from CefBrowserContentsDelegate::RenderFrameHostStateChanged.
@ -102,32 +100,22 @@ class CefBrowserInfo : public base::RefCountedThreadSafe<CefBrowserInfo> {
const content::GlobalRenderFrameHostId& parent_global_id);
// Returns the frame object matching the specified host or nullptr if no match
// is found. Nullptr will also be returned if a guest view match is found
// because we don't create frame objects for guest views. If |is_guest_view|
// is non-nullptr it will be set to true in this case. Must be called on the
// UI thread.
// is found. Must be called on the UI thread.
CefRefPtr<CefFrameHostImpl> GetFrameForHost(
const content::RenderFrameHost* host,
bool* is_guest_view = nullptr,
bool prefer_speculative = false) const;
// Returns the frame object matching the specified ID/token or nullptr if no
// match is found. Nullptr will also be returned if a guest view match is
// found because we don't create frame objects for guest views. If
// |is_guest_view| is non-nullptr it will be set to true in this case. Safe to
// call from any thread.
// match is found. Safe to call from any thread.
CefRefPtr<CefFrameHostImpl> GetFrameForGlobalId(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view = nullptr,
bool prefer_speculative = false) const;
CefRefPtr<CefFrameHostImpl> GetFrameForGlobalToken(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view = nullptr,
bool prefer_speculative = false) const;
// Returns all non-speculative frame objects that currently exist. Guest views
// will be excluded because they don't have a frame object. Safe to call from
// any thread.
// Returns all non-speculative frame objects that currently exist. Safe to
// call from any thread.
using FrameHostList = std::set<CefRefPtr<CefFrameHostImpl>>;
FrameHostList GetAllFrames() const;
@ -184,7 +172,6 @@ class CefBrowserInfo : public base::RefCountedThreadSafe<CefBrowserInfo> {
content::RenderFrameHost* host_;
content::GlobalRenderFrameHostId global_id_;
bool is_guest_view_;
bool is_main_frame_;
bool is_speculative_;
bool is_in_bfcache_ = false;

100
libcef/browser/browser_info_manager.cc
View File

@ -97,7 +97,7 @@ scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::CreatePopupBrowserInfo(
// Continue any pending NewBrowserInfo request.
ContinueNewBrowserInfo(frame_host->GetGlobalFrameToken(), browser_info,
/*is_guest_view=*/false);
/*is_excluded=*/false);
return browser_info;
}
@ -307,15 +307,13 @@ void CefBrowserInfoManager::OnGetNewBrowserInfo(
base::AutoLock lock_scope(browser_info_lock_);
bool is_guest_view = false;
scoped_refptr<CefBrowserInfo> browser_info =
GetBrowserInfoInternal(global_token, &is_guest_view);
GetBrowserInfoInternal(global_token);
if (browser_info) {
// Send the response immediately.
SendNewBrowserInfoResponse(browser_info, is_guest_view, std::move(callback),
callback_runner);
SendNewBrowserInfoResponse(browser_info, /*is_excluded=*/false,
std::move(callback), callback_runner);
return;
}
@ -347,7 +345,7 @@ void CefBrowserInfoManager::OnGetNewBrowserInfo(
kNewBrowserInfoResponseTimeoutMs);
}
// Check for PDF viewer or print preview frames.
// Check for excluded content (PDF viewer or print preview).
CEF_POST_TASK(
CEF_UIT,
base::BindOnce(
@ -369,29 +367,27 @@ void CefBrowserInfoManager::CheckExcludedNewBrowserInfoOnUIThread(
return;
}
// PDF viewer and print preview create multiple renderer processes. Not all
// of those processes are currently tracked by CefBrowserInfo, so we also
// treat frames from untracked processes (like the print preview dialog) as
// guest views in the renderer process.
// PDF viewer and print preview create multiple renderer processes. These
// excluded processes are not tracked by CefBrowserInfo.
CefBrowserInfo* browser_info;
bool excluded_type;
GetFrameHost(rfh, /*prefer_speculative=*/true, &browser_info, &excluded_type);
if (browser_info && excluded_type) {
bool is_excluded;
GetFrameHost(rfh, /*prefer_speculative=*/true, &browser_info, &is_excluded);
if (browser_info && is_excluded) {
g_info_manager->ContinueNewBrowserInfo(global_token, browser_info,
/*is_guest_view=*/true);
/*is_excluded=*/true);
}
}
void CefBrowserInfoManager::ContinueNewBrowserInfo(
const content::GlobalRenderFrameHostToken& global_token,
scoped_refptr<CefBrowserInfo> browser_info,
bool is_guest_view) {
bool is_excluded) {
base::AutoLock lock_scope(browser_info_lock_);
// Continue any pending NewBrowserInfo request.
auto it = pending_new_browser_info_map_.find(global_token);
if (it != pending_new_browser_info_map_.end()) {
SendNewBrowserInfoResponse(browser_info, is_guest_view,
SendNewBrowserInfoResponse(browser_info, is_excluded,
std::move(it->second->callback),
it->second->callback_runner);
pending_new_browser_info_map_.erase(it);
@ -444,17 +440,15 @@ void CefBrowserInfoManager::DestroyAllBrowsers() {
}
scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfo(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view) {
const content::GlobalRenderFrameHostId& global_id) {
base::AutoLock lock_scope(browser_info_lock_);
return GetBrowserInfoInternal(global_id, is_guest_view);
return GetBrowserInfoInternal(global_id);
}
scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfo(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view) {
const content::GlobalRenderFrameHostToken& global_token) {
base::AutoLock lock_scope(browser_info_lock_);
return GetBrowserInfoInternal(global_token, is_guest_view);
return GetBrowserInfoInternal(global_token);
}
bool CefBrowserInfoManager::MaybeAllowNavigation(
@ -496,7 +490,7 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfoManager::GetFrameHost(
content::RenderFrameHost* rfh,
bool prefer_speculative,
CefBrowserInfo** browser_info,
bool* excluded_type) {
bool* is_excluded) {
CEF_REQUIRE_UIT();
DCHECK(rfh);
@ -510,28 +504,22 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfoManager::GetFrameHost(
bool excluded =
is_pdf_process || is_browser_process_guest || is_print_preview_dialog;
bool guest_view = false;
CefRefPtr<CefFrameHostImpl> frame;
// A BrowserHost may match an excluded RFH type. Some associations are
// registered directly via CefBrowserInfo::MaybeCreateFrame and some are
// discovered indirectly via extensions::GetOwnerForGuestContents.
auto browser = CefBrowserHostBase::GetBrowserForHost(rfh);
if (browser) {
frame = browser->browser_info()->GetFrameForHost(rfh, &guest_view,
prefer_speculative);
excluded |= guest_view;
// A FrameHost should never exist for an excluded type.
DCHECK(!frame || !excluded);
if (browser && !excluded) {
frame = browser->browser_info()->GetFrameForHost(rfh, prefer_speculative);
}
if (browser_info) {
*browser_info = browser ? browser->browser_info().get() : nullptr;
}
if (excluded_type) {
*excluded_type = excluded;
if (is_excluded) {
*is_excluded = excluded;
}
if (VLOG_IS_ON(1)) {
@ -539,9 +527,7 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfoManager::GetFrameHost(
frame_util::GetFrameDebugString(rfh->GetGlobalFrameToken());
const bool is_main = rfh->GetParent() == nullptr;
VLOG(1) << "frame " << debug_string
<< " registered_guest_view=" << guest_view
<< ", pdf_process=" << is_pdf_process
VLOG(1) << "frame " << debug_string << ", pdf_process=" << is_pdf_process
<< ", browser_process_guest=" << is_browser_process_guest
<< ", print_preview_dialog=" << is_print_preview_dialog
<< ", main=" << is_main << (browser ? "" : ", has no BrowserHost")
@ -686,26 +672,16 @@ CefBrowserInfoManager::PopPendingPopup(PendingPopup::Step previous_step_alloy,
}
scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfoInternal(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view) {
const content::GlobalRenderFrameHostId& global_id) {
browser_info_lock_.AssertAcquired();
if (is_guest_view) {
*is_guest_view = false;
}
if (!frame_util::IsValidGlobalId(global_id)) {
return nullptr;
}
for (const auto& browser_info : browser_info_list_) {
bool is_guest_view_tmp;
auto frame =
browser_info->GetFrameForGlobalId(global_id, &is_guest_view_tmp);
if (frame || is_guest_view_tmp) {
if (is_guest_view) {
*is_guest_view = is_guest_view_tmp;
}
auto frame = browser_info->GetFrameForGlobalId(global_id);
if (frame) {
return browser_info;
}
}
@ -714,26 +690,16 @@ scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfoInternal(
}
scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfoInternal(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view) {
const content::GlobalRenderFrameHostToken& global_token) {
browser_info_lock_.AssertAcquired();
if (is_guest_view) {
*is_guest_view = false;
}
if (!frame_util::IsValidGlobalToken(global_token)) {
return nullptr;
}
for (const auto& browser_info : browser_info_list_) {
bool is_guest_view_tmp;
auto frame =
browser_info->GetFrameForGlobalToken(global_token, &is_guest_view_tmp);
if (frame || is_guest_view_tmp) {
if (is_guest_view) {
*is_guest_view = is_guest_view_tmp;
}
auto frame = browser_info->GetFrameForGlobalToken(global_token);
if (frame) {
return browser_info;
}
}
@ -744,20 +710,20 @@ scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfoInternal(
// static
void CefBrowserInfoManager::SendNewBrowserInfoResponse(
scoped_refptr<CefBrowserInfo> browser_info,
bool is_guest_view,
bool is_excluded,
cef::mojom::BrowserManager::GetNewBrowserInfoCallback callback,
scoped_refptr<base::SequencedTaskRunner> callback_runner) {
if (!callback_runner->RunsTasksInCurrentSequence()) {
callback_runner->PostTask(
FROM_HERE,
base::BindOnce(&CefBrowserInfoManager::SendNewBrowserInfoResponse,
browser_info, is_guest_view, std::move(callback),
browser_info, is_excluded, std::move(callback),
callback_runner));
return;
}
auto params = cef::mojom::NewBrowserInfo::New();
params->is_guest_view = is_guest_view;
params->is_excluded = is_excluded;
if (browser_info) {
params->browser_id = browser_info->browser_id();
@ -783,7 +749,7 @@ void CefBrowserInfoManager::SendNewBrowserInfoResponse(
// static
void CefBrowserInfoManager::CancelNewBrowserInfoResponse(
PendingNewBrowserInfo* pending_info) {
SendNewBrowserInfoResponse(/*browser_info=*/nullptr, /*is_guest_view=*/false,
SendNewBrowserInfoResponse(/*browser_info=*/nullptr, /*is_excluded=*/false,
std::move(pending_info->callback),
pending_info->callback_runner);
}

31
libcef/browser/browser_info_manager.h
View File

@ -110,9 +110,9 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
// browser info to the renderer process. If the browser info already exists
// the response will be sent immediately. Otherwise, the response will be sent
// when CreatePopupBrowserInfo creates the browser info. The info will already
// exist for explicitly created browsers and guest views. It may sometimes
// already exist for traditional popup browsers depending on timing. See
// comments on PendingPopup for more information.
// exist for explicitly created browsers. It may sometimes already exist for
// traditional popup browsers depending on timing. See comments on
// PendingPopup for more information.
void OnGetNewBrowserInfo(
const content::GlobalRenderFrameHostToken& global_token,
cef::mojom::BrowserManager::GetNewBrowserInfoCallback callback);
@ -127,15 +127,10 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
// Returns the CefBrowserInfo matching the specified ID/token or nullptr if no
// match is found. It is allowed to add new callers of this method but
// consider using CefBrowserHostBase::GetBrowserForGlobalId/Token() instead.
// If |is_guest_view| is non-nullptr it will be set to true if the ID/token
// matches a guest view associated with the returned browser info instead of
// the browser itself.
scoped_refptr<CefBrowserInfo> GetBrowserInfo(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view = nullptr);
const content::GlobalRenderFrameHostId& global_id);
scoped_refptr<CefBrowserInfo> GetBrowserInfo(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view = nullptr);
const content::GlobalRenderFrameHostToken& global_token);
// Returns all existing CefBrowserInfo objects.
using BrowserInfoList = std::list<scoped_refptr<CefBrowserInfo>>;
@ -152,13 +147,13 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
bool use_default_browser_creation);
// Returns the FrameHost associated with |rfh|, if any. |browser_info| and
// |excluded_type| will be populated if non-nullptr. An excluded type will not
// |is_excluded| will be populated if non-nullptr. An excluded type will not
// have a FrameHost but |browser_info| may still be populated if the
// association is known.
static CefRefPtr<CefFrameHostImpl> GetFrameHost(content::RenderFrameHost* rfh,
bool prefer_speculative,
CefBrowserInfo** browser_info,
bool* excluded_type);
bool* is_excluded);
// Returns true if |rfh| should be excluded (no FrameHost created).
static bool IsExcludedFrameHost(content::RenderFrameHost* rfh);
@ -171,7 +166,7 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
// - CanCreateWindow (UIT):
// Provides an opportunity to cancel the popup (calls OnBeforePopup) and
// creates the new platform delegate for the popup. If the popup owner is
// an extension guest view then the popup is canceled and
// an extension guest view (PDF viewer) then the popup is canceled and
// WebContentsDelegate::OpenURLFromTab is called via the
// CefBrowserHostBase::MaybeAllowNavigation implementation.
// And then the following calls may occur at the same time:
@ -237,11 +232,9 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
// Retrieves the BrowserInfo matching the specified ID/token.
scoped_refptr<CefBrowserInfo> GetBrowserInfoInternal(
const content::GlobalRenderFrameHostId& global_id,
bool* is_guest_view);
const content::GlobalRenderFrameHostId& global_id);
scoped_refptr<CefBrowserInfo> GetBrowserInfoInternal(
const content::GlobalRenderFrameHostToken& global_token,
bool* is_guest_view);
const content::GlobalRenderFrameHostToken& global_token);
// Check for excluded frames that can be responded to immediately.
static void CheckExcludedNewBrowserInfoOnUIThread(
@ -250,12 +243,12 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
void ContinueNewBrowserInfo(
const content::GlobalRenderFrameHostToken& global_token,
scoped_refptr<CefBrowserInfo> browser_info,
bool is_guest_view);
bool is_excluded);
// Send the response for a pending OnGetNewBrowserInfo request.
static void SendNewBrowserInfoResponse(
scoped_refptr<CefBrowserInfo> browser_info,
bool is_guest_view,
bool is_excluded,
cef::mojom::BrowserManager::GetNewBrowserInfoCallback callback,
scoped_refptr<base::SequencedTaskRunner> callback_runner);

2
libcef/browser/chrome/chrome_context_menu_handler.cc
View File

@ -256,7 +256,7 @@ class CefContextMenuObserver : public RenderViewContextMenuObserver,
// May return nullptr if the frame is destroyed while the menu is pending.
auto* rfh = context_menu_->GetRenderFrameHost();
if (rfh) {
// May return nullptr for guest views.
// May return nullptr for excluded views.
frame = browser_->GetFrameForHost(rfh);
}
if (!frame) {

29
libcef/browser/chrome/extensions/chrome_mime_handler_view_guest_delegate_cef.cc
View File

@ -6,7 +6,6 @@
#include "libcef/browser/chrome/extensions/chrome_mime_handler_view_guest_delegate_cef.h"
#include "libcef/browser/browser_host_base.h"
#include "libcef/browser/browser_info.h"
#include "libcef/browser/chrome/chrome_context_menu_handler.h"
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
@ -15,37 +14,11 @@ namespace extensions {
ChromeMimeHandlerViewGuestDelegateCef::ChromeMimeHandlerViewGuestDelegateCef(
MimeHandlerViewGuest* guest)
: guest_(guest), owner_web_contents_(guest_->owner_web_contents()) {}
: owner_web_contents_(guest->owner_web_contents()) {}
ChromeMimeHandlerViewGuestDelegateCef::
~ChromeMimeHandlerViewGuestDelegateCef() = default;
void ChromeMimeHandlerViewGuestDelegateCef::OnGuestAttached() {
content::WebContents* web_contents = guest_->web_contents();
DCHECK(web_contents);
auto owner_browser =
CefBrowserHostBase::GetBrowserForContents(owner_web_contents_);
DCHECK(owner_browser);
// Associate guest state information with the owner browser.
owner_browser->browser_info()->MaybeCreateFrame(
web_contents->GetPrimaryMainFrame(), true /* is_guest_view */);
}
void ChromeMimeHandlerViewGuestDelegateCef::OnGuestDetached() {
content::WebContents* web_contents = guest_->web_contents();
DCHECK(web_contents);
auto owner_browser =
CefBrowserHostBase::GetBrowserForContents(owner_web_contents_);
DCHECK(owner_browser);
// Disassociate guest state information with the owner browser.
owner_browser->browser_info()->RemoveFrame(
web_contents->GetPrimaryMainFrame());
}
bool ChromeMimeHandlerViewGuestDelegateCef::HandleContextMenu(
content::RenderFrameHost& render_frame_host,
const content::ContextMenuParams& params) {

6
libcef/browser/chrome/extensions/chrome_mime_handler_view_guest_delegate_cef.h
View File

@ -7,10 +7,11 @@
#define CEF_LIBCEF_BROWSER_CHROME_EXTENSIONS_CHROME_MIME_HANDLER_VIEW_GUEST_DELEGATE_CEF_H_
#include "chrome/browser/guest_view/mime_handler_view/chrome_mime_handler_view_guest_delegate.h"
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
namespace extensions {
class MimeHandlerViewGuest;
class ChromeMimeHandlerViewGuestDelegateCef
: public ChromeMimeHandlerViewGuestDelegate {
public:
@ -24,13 +25,10 @@ class ChromeMimeHandlerViewGuestDelegateCef
~ChromeMimeHandlerViewGuestDelegateCef() override;
// MimeHandlerViewGuestDelegate methods.
void OnGuestAttached() override;
void OnGuestDetached() override;
bool HandleContextMenu(content::RenderFrameHost& render_frame_host,
const content::ContextMenuParams& params) override;
private:
MimeHandlerViewGuest* guest_; // Owns us.
content::WebContents* owner_web_contents_;
};

4
libcef/browser/extensions/extension_system.cc
View File

@ -209,8 +209,8 @@ void CefExtensionSystem::Init() {
// MimeHandlerViewGuest and CefMimeHandlerViewGuestDelegate in the browser
// process.
// 11.MimeHandlerViewGuest::CreateWebContents creates a new guest WebContents
// (is_guest_view=true) to host the PDF extension and the PDF resource
// stream is retrieved via MimeHandlerStreamManager::ReleaseStream.
// to host the PDF extension and the PDF resource stream is retrieved via
// MimeHandlerStreamManager::ReleaseStream.
// 12.MimeHandlerViewGuest::DidAttachToEmbedder calls
// CefMimeHandlerViewGuestDelegate::OnGuestAttached to associate the guest
// WebContents routing IDs with the owner CefBrowser. MimeHandlerViewGuest

31
libcef/browser/extensions/mime_handler_view_guest_delegate.cc
View File

@ -6,9 +6,6 @@
#include "libcef/browser/extensions/mime_handler_view_guest_delegate.h"
#include "libcef/browser/alloy/alloy_browser_host_impl.h"
#include "libcef/browser/alloy/alloy_content_browser_client.h"
#include "libcef/browser/browser_context.h"
#include "libcef/browser/browser_info.h"
#include "libcef/browser/osr/web_contents_view_osr.h"
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
@ -17,7 +14,7 @@ namespace extensions {
CefMimeHandlerViewGuestDelegate::CefMimeHandlerViewGuestDelegate(
MimeHandlerViewGuest* guest)
: guest_(guest), owner_web_contents_(guest_->owner_web_contents()) {}
: owner_web_contents_(guest->owner_web_contents()) {}
CefMimeHandlerViewGuestDelegate::~CefMimeHandlerViewGuestDelegate() = default;
@ -37,32 +34,6 @@ void CefMimeHandlerViewGuestDelegate::OverrideWebContentsCreateParams(
}
}
void CefMimeHandlerViewGuestDelegate::OnGuestAttached() {
content::WebContents* web_contents = guest_->web_contents();
DCHECK(web_contents);
CefRefPtr<AlloyBrowserHostImpl> owner_browser =
AlloyBrowserHostImpl::GetBrowserForContents(owner_web_contents_);
DCHECK(owner_browser);
// Associate guest state information with the owner browser.
owner_browser->browser_info()->MaybeCreateFrame(
web_contents->GetPrimaryMainFrame(), true /* is_guest_view */);
}
void CefMimeHandlerViewGuestDelegate::OnGuestDetached() {
content::WebContents* web_contents = guest_->web_contents();
DCHECK(web_contents);
CefRefPtr<AlloyBrowserHostImpl> owner_browser =
AlloyBrowserHostImpl::GetBrowserForContents(owner_web_contents_);
DCHECK(owner_browser);
// Disassociate guest state information with the owner browser.
owner_browser->browser_info()->RemoveFrame(
web_contents->GetPrimaryMainFrame());
}
bool CefMimeHandlerViewGuestDelegate::HandleContextMenu(
content::RenderFrameHost& render_frame_host,
const content::ContextMenuParams& params) {

6
libcef/browser/extensions/mime_handler_view_guest_delegate.h
View File

@ -6,7 +6,6 @@
#ifndef CEF_LIBCEF_BROWSER_EXTENSIONS_MIME_HANDLER_VIEW_GUEST_DELEGATE_H_
#define CEF_LIBCEF_BROWSER_EXTENSIONS_MIME_HANDLER_VIEW_GUEST_DELEGATE_H_
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h"
namespace content {
@ -15,6 +14,8 @@ struct ContextMenuParams;
namespace extensions {
class MimeHandlerViewGuest;
class CefMimeHandlerViewGuestDelegate : public MimeHandlerViewGuestDelegate {
public:
explicit CefMimeHandlerViewGuestDelegate(MimeHandlerViewGuest* guest);
@ -29,13 +30,10 @@ class CefMimeHandlerViewGuestDelegate : public MimeHandlerViewGuestDelegate {
// MimeHandlerViewGuestDelegate methods.
void OverrideWebContentsCreateParams(
content::WebContents::CreateParams* params) override;
void OnGuestAttached() override;
void OnGuestDetached() override;
bool HandleContextMenu(content::RenderFrameHost& render_frame_host,
const content::ContextMenuParams& params) override;
private:
MimeHandlerViewGuest* guest_; // Owns us.
content::WebContents* owner_web_contents_;
};

6
libcef/browser/javascript_dialog_manager.cc
View File

@ -69,9 +69,9 @@ javascript_dialogs::TabModalDialogManager* GetTabModalDialogManager(
return manager;
}
// Try the owner WebContents if the dialog originates from a guest view such
// as the PDF viewer or Print Preview.
// This is safe to call even if Alloy extensions are disabled.
// Try the owner WebContents if the dialog originates from an excluded view
// such as the PDF viewer or Print Preview. This is safe to call even if Alloy
// extensions are disabled.
if (auto* owner_contents =
extensions::GetOwnerForGuestContents(web_contents)) {
return javascript_dialogs::TabModalDialogManager::FromWebContents(

4
libcef/browser/net_service/resource_request_handler_wrapper.cc
View File

@ -1336,7 +1336,7 @@ std::unique_ptr<InterceptedRequestHandler> CreateInterceptedRequestHandler(
if (frame) {
browserPtr = CefBrowserHostBase::GetBrowserForHost(frame);
if (browserPtr) {
// May return nullptr for guest view requests.
// May return nullptr for excluded view requests.
framePtr = browserPtr->GetFrameForHost(frame);
if (!framePtr) {
framePtr = browserPtr->GetMainFrame();
@ -1407,7 +1407,7 @@ std::unique_ptr<InterceptedRequestHandler> CreateInterceptedRequestHandler(
browserPtr = CefBrowserHostBase::GetBrowserForHost(frame);
if (browserPtr) {
// May return nullptr for guest view requests.
// May return nullptr for excluded view requests.
framePtr = browserPtr->GetFrameForHost(frame);
if (!framePtr) {
framePtr = browserPtr->GetMainFrame();

12
libcef/browser/request_context_impl.cc
View File

@ -702,18 +702,14 @@ cef_color_variant_t CefRequestContextImpl::GetChromeColorSchemeVariant() {
void CefRequestContextImpl::OnRenderFrameCreated(
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view) {
browser_context_->OnRenderFrameCreated(this, global_id, is_main_frame,
is_guest_view);
bool is_main_frame) {
browser_context_->OnRenderFrameCreated(this, global_id, is_main_frame);
}
void CefRequestContextImpl::OnRenderFrameDeleted(
const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view) {
browser_context_->OnRenderFrameDeleted(this, global_id, is_main_frame,
is_guest_view);
bool is_main_frame) {
browser_context_->OnRenderFrameDeleted(this, global_id, is_main_frame);
}
// static

16
libcef/browser/request_context_impl.h
View File

@ -139,19 +139,15 @@ class CefRequestContextImpl : public CefRequestContext {
const CefRequestContextSettings& settings() const { return config_.settings; }
// Called from CefBrowserContentsDelegate::RenderFrameCreated or
// CefMimeHandlerViewGuestDelegate::OnGuestAttached when a render frame is
// created.
// Called from CefBrowserContentsDelegate::RenderFrameCreated when a render
// frame is created.
void OnRenderFrameCreated(const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view);
bool is_main_frame);
// Called from CefBrowserContentsDelegate::RenderFrameDeleted or
// CefMimeHandlerViewGuestDelegate::OnGuestDetached when a render frame is
// deleted.
// Called from CefBrowserContentsDelegate::RenderFrameDeleted when a render
// frame is deleted.
void OnRenderFrameDeleted(const content::GlobalRenderFrameHostId& global_id,
bool is_main_frame,
bool is_guest_view);
bool is_main_frame);
private:
friend class CefRequestContext;

2
libcef/common/mojom/cef.mojom
View File

@ -119,7 +119,7 @@ struct NewBrowserInfo {
bool? is_popup;
bool? is_windowless;
bool? print_preview_enabled;
bool is_guest_view;
bool is_excluded;
mojo_base.mojom.DictionaryValue? extra_info;
};

51
libcef/renderer/render_manager.cc
View File

@ -52,10 +52,10 @@ CefRenderManager* g_manager = nullptr;
} // namespace
// Placeholder object for guest views.
class CefGuestView : public blink::WebViewObserver {
// Placeholder object for excluded views.
class CefExcludedView : public blink::WebViewObserver {
public:
CefGuestView(CefRenderManager* manager,
CefExcludedView(CefRenderManager* manager,
blink::WebView* web_view,
std::optional<bool> is_windowless,
std::optional<bool> print_preview_enabled)
@ -71,7 +71,7 @@ class CefGuestView : public blink::WebViewObserver {
private:
// RenderViewObserver methods.
void OnDestruct() override { manager_->OnGuestViewDestroyed(this); }
void OnDestruct() override { manager_->OnExcludedViewDestroyed(this); }
CefRenderManager* const manager_;
const std::optional<bool> is_windowless_;
@ -306,8 +306,8 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
return nullptr;
}
// Don't create another browser or guest view object if one already exists for
// the view.
// Don't create another browser or excluded view object if one already exists
// for the view.
auto browser = GetBrowserForView(web_view);
if (browser) {
if (is_windowless) {
@ -319,13 +319,13 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
return browser;
}
auto guest_view = GetGuestViewForView(web_view);
if (guest_view) {
auto excluded_view = GetExcludedViewForView(web_view);
if (excluded_view) {
if (is_windowless) {
*is_windowless = guest_view->is_windowless();
*is_windowless = excluded_view->is_windowless();
}
if (print_preview_enabled) {
*print_preview_enabled = guest_view->print_preview_enabled();
*print_preview_enabled = excluded_view->print_preview_enabled();
}
return nullptr;
}
@ -346,13 +346,13 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
*print_preview_enabled = params->print_preview_enabled;
}
if (params->is_guest_view || params->browser_id < 0) {
// Don't create a CefBrowser for a guest view (PDF renderer, PDF extension
// or print preview dialog), or if the new browser info response has timed
// out.
guest_views_.insert(std::make_pair(
if (params->is_excluded || params->browser_id < 0) {
// Don't create a CefBrowser for excluded content (PDF renderer, PDF
// extension or print preview dialog), or if the new browser info response
// has timed out.
excluded_views_.insert(std::make_pair(
web_view,
std::make_unique<CefGuestView>(this, web_view, params->is_windowless,
std::make_unique<CefExcludedView>(this, web_view, params->is_windowless,
params->print_preview_enabled)));
return nullptr;
}
@ -398,26 +398,27 @@ void CefRenderManager::OnBrowserDestroyed(CefBrowserImpl* browser) {
DCHECK(false);
}
CefGuestView* CefRenderManager::GetGuestViewForView(blink::WebView* view) {
CefExcludedView* CefRenderManager::GetExcludedViewForView(
blink::WebView* view) {
CEF_REQUIRE_RT_RETURN(nullptr);
GuestViewMap::const_iterator it = guest_views_.find(view);
if (it != guest_views_.end()) {
ExcludedViewMap::const_iterator it = excluded_views_.find(view);
if (it != excluded_views_.end()) {
return it->second.get();
}
return nullptr;
}
void CefRenderManager::OnGuestViewDestroyed(CefGuestView* guest_view) {
GuestViewMap::iterator it = guest_views_.begin();
for (; it != guest_views_.end(); ++it) {
if (it->second.get() == guest_view) {
guest_views_.erase(it);
void CefRenderManager::OnExcludedViewDestroyed(CefExcludedView* excluded_view) {
ExcludedViewMap::iterator it = excluded_views_.begin();
for (; it != excluded_views_.end(); ++it) {
if (it->second.get() == excluded_view) {
excluded_views_.erase(it);
return;
}
}
// No guest view was found in the map.
// No excluded view was found in the map.
DCHECK(false);
}

21
libcef/renderer/render_manager.h
View File

@ -31,7 +31,7 @@ class BinderMap;
} // namespace mojo
class CefBrowserImpl;
class CefGuestView;
class CefExcludedView;
class CefRenderFrameObserver;
// Singleton object for managing BrowserImpl instances. Only accessed on the
@ -77,7 +77,7 @@ class CefRenderManager : public cef::mojom::RenderManager {
private:
friend class CefBrowserImpl;
friend class CefGuestView;
friend class CefExcludedView;
// Binds receivers for the RenderManager interface.
void BindReceiver(mojo::PendingReceiver<cef::mojom::RenderManager> receiver);
@ -91,7 +91,7 @@ class CefRenderManager : public cef::mojom::RenderManager {
void WebKitInitialized();
// Maybe create a new browser object, return the existing one, or return
// nullptr for guest views.
// nullptr for excluded views.
CefRefPtr<CefBrowserImpl> MaybeCreateBrowser(
blink::WebView* web_view,
content::RenderFrame* render_frame,
@ -102,19 +102,20 @@ class CefRenderManager : public cef::mojom::RenderManager {
// Called from CefBrowserImpl::OnDestruct().
void OnBrowserDestroyed(CefBrowserImpl* browser);
// Returns the guest view associated with the specified RenderView if any.
CefGuestView* GetGuestViewForView(blink::WebView* view);
// Returns the excluded view associated with the specified RenderView if any.
CefExcludedView* GetExcludedViewForView(blink::WebView* view);
// Called from CefGuestView::OnDestruct().
void OnGuestViewDestroyed(CefGuestView* guest_view);
// Called from CefExcludedView::OnDestruct().
void OnExcludedViewDestroyed(CefExcludedView* excluded_view);
// Map of RenderView pointers to CefBrowserImpl references.
using BrowserMap = std::map<blink::WebView*, CefRefPtr<CefBrowserImpl>>;
BrowserMap browsers_;
// Map of RenderView poiners to CefGuestView implementations.
using GuestViewMap = std::map<blink::WebView*, std::unique_ptr<CefGuestView>>;
GuestViewMap guest_views_;
// Map of RenderView poiners to CefExcludedView implementations.
using ExcludedViewMap =
std::map<blink::WebView*, std::unique_ptr<CefExcludedView>>;
ExcludedViewMap excluded_views_;
// Cross-origin white list entries that need to be registered with WebKit.
std::vector<cef::mojom::CrossOriginWhiteListEntryPtr>

3
patch/patch.cfg
View File

@ -150,8 +150,7 @@ patches = [
'name': 'web_contents_1257_1565',
},
{
# Support custom RenderWidgetHostViewOSR for MimeHandlerViewGuest and
# expose OnGuestAttached/Detached notifications.
# Support custom RenderWidgetHostViewOSR for MimeHandlerViewGuest.
# https://github.com/chromiumembedded/cef/issues/1565
# https://github.com/chromiumembedded/cef/issues/2727
'name': 'mime_handler_view_guest_1565_2727',

53
patch/patches/mime_handler_view_guest_1565_2727.patch
View File

@ -12,7 +12,7 @@ index 285dc38950991..326646bb585da 100644
virtual ~WebContentsView() = default;
diff --git extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc
index bd8b5ddfd8659..0f1e6e2ed9ea2 100644
index bd8b5ddfd8659..767c0ec89ef7a 100644
--- extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc
+++ extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc
@@ -205,6 +205,8 @@ void MimeHandlerViewGuest::CreateWebContents(
@ -24,51 +24,8 @@ index bd8b5ddfd8659..0f1e6e2ed9ea2 100644
std::move(callback).Run(std::move(owned_this),
WebContents::CreateWithSessionStorage(
params, owner_web_contents()
@@ -213,6 +215,10 @@ void MimeHandlerViewGuest::CreateWebContents(
}
void MimeHandlerViewGuest::DidAttachToEmbedder() {
+ is_guest_attached_ = true;
+ if (delegate_)
+ delegate_->OnGuestAttached();
+
DCHECK(stream_->handler_url().SchemeIs(extensions::kExtensionScheme));
GetController().LoadURL(stream_->handler_url(), content::Referrer(),
ui::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
@@ -489,6 +495,14 @@ void MimeHandlerViewGuest::DidFinishNavigation(
}
}
+void MimeHandlerViewGuest::WebContentsDestroyed() {
+ if (is_guest_attached_ && delegate_)
+ delegate_->OnGuestDetached();
+
+ // May delete |this|.
+ GuestView<MimeHandlerViewGuest>::WebContentsDestroyed();
+}
+
void MimeHandlerViewGuest::FuseBeforeUnloadControl(
mojo::PendingReceiver<mime_handler::BeforeUnloadControl> receiver) {
if (!pending_before_unload_control_)
diff --git extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h
index f0b71aba6dfb4..a8b4b6dc27fa7 100644
--- extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h
+++ extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h
@@ -198,10 +198,12 @@ class MimeHandlerViewGuest
void ReadyToCommitNavigation(
content::NavigationHandle* navigation_handle) final;
void DidFinishNavigation(content::NavigationHandle* navigation_handle) final;
+ void WebContentsDestroyed() override;
std::unique_ptr<MimeHandlerViewGuestDelegate> delegate_;
std::unique_ptr<StreamContainer> stream_;
+ bool is_guest_attached_ = false;
bool is_guest_fullscreen_ = false;
bool is_embedder_fullscreen_ = false;
bool plugin_can_save_ = false;
diff --git extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h
index 7f59e7925084e..777b8a3cf103a 100644
index 7f59e7925084e..e3e69dc6d3a43 100644
--- extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h
+++ extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest_delegate.h
@@ -7,6 +7,8 @@
@ -80,17 +37,13 @@ index 7f59e7925084e..777b8a3cf103a 100644
namespace content {
class RenderFrameHost;
struct ContextMenuParams;
@@ -25,6 +27,14 @@ class MimeHandlerViewGuestDelegate {
@@ -25,6 +27,10 @@ class MimeHandlerViewGuestDelegate {
virtual ~MimeHandlerViewGuestDelegate() {}
+ // Provides an opportunity to supply a custom view implementation.
+ virtual void OverrideWebContentsCreateParams(
+ content::WebContents::CreateParams* params) {}
+
+ // Called when a guest is attached or detached.
+ virtual void OnGuestAttached() {}
+ virtual void OnGuestDetached() {}
+
// Handles context menu, or returns false if unhandled.
//