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

Update to Chromium version 80.0.3987.0 (#722274)

Browse Source
This commit is contained in:
Alexander Guettler
2020-02-10 12:10:17 -05:00
committed by Marshall Greenblatt
parent ed39922f85
commit 71768ea6c3
131 changed files with 1620 additions and 1394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
libcef/browser/browser_context.cc
View File

@@ -37,7 +37,7 @@
#include "components/proxy_config/pref_proxy_config_tracker_impl.h"
#include "components/user_prefs/user_prefs.h"
#include "components/visitedlink/browser/visitedlink_event_listener.h"
#include "components/visitedlink/browser/visitedlink_master.h"
#include "components/visitedlink/browser/visitedlink_writer.h"
#include "components/zoom/zoom_event_manager.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
@@ -167,8 +167,8 @@ base::LazyInstance<ImplManager>::Leaky g_manager = LAZY_INSTANCE_INITIALIZER;
} // namespace
// Creates and manages VisitedLinkEventListener objects for each
// CefBrowserContext sharing the same VisitedLinkMaster.
class CefVisitedLinkListener : public visitedlink::VisitedLinkMaster::Listener {
// CefBrowserContext sharing the same VisitedLinkWriter.
class CefVisitedLinkListener : public visitedlink::VisitedLinkWriter::Listener {
public:
CefVisitedLinkListener() { DCHECK(listener_map_.empty()); }
@@ -186,7 +186,7 @@ class CefVisitedLinkListener : public visitedlink::VisitedLinkMaster::Listener {
listener_map_.erase(it);
}
// visitedlink::VisitedLinkMaster::Listener methods.
// visitedlink::VisitedLinkWriter::Listener methods.
void NewTable(base::ReadOnlySharedMemoryRegion* table_region) override {
CEF_REQUIRE_UIT();
@@ -341,7 +341,7 @@ void CefBrowserContext::Initialize() {
if (!cache_path_.empty())
visited_link_path = cache_path_.Append(FILE_PATH_LITERAL("Visited Links"));
visitedlink_listener_ = new CefVisitedLinkListener;
visitedlink_master_.reset(new visitedlink::VisitedLinkMaster(
visitedlink_master_.reset(new visitedlink::VisitedLinkWriter(
visitedlink_listener_, this, !visited_link_path.empty(), false,
visited_link_path, 0));
visitedlink_listener_->CreateListenerForContext(this);
@@ -582,7 +582,7 @@ HostContentSettingsMap* CefBrowserContext::GetHostContentSettingsMap() {
plugin_policy = CONTENT_SETTING_BLOCK;
}
host_content_settings_map_->SetDefaultContentSetting(
CONTENT_SETTINGS_TYPE_PLUGINS, plugin_policy);
ContentSettingsType::PLUGINS, plugin_policy);
}
}
return host_content_settings_map_.get();

4
libcef/browser/browser_context.h
View File

@@ -95,7 +95,7 @@ class CefExtensionSystem;
}
namespace visitedlink {
class VisitedLinkMaster;
class VisitedLinkWriter;
}
// Main entry point for configuring behavior on a per-browser basis. An instance
@@ -298,7 +298,7 @@ class CefBrowserContext : public ChromeProfileStub,
std::unique_ptr<CefDownloadManagerDelegate> download_manager_delegate_;
std::unique_ptr<CefSSLHostStateDelegate> ssl_host_state_delegate_;
scoped_refptr<HostContentSettingsMap> host_content_settings_map_;
std::unique_ptr<visitedlink::VisitedLinkMaster> visitedlink_master_;
std::unique_ptr<visitedlink::VisitedLinkWriter> visitedlink_master_;
// |visitedlink_listener_| is owned by visitedlink_master_.
CefVisitedLinkListener* visitedlink_listener_;
bool should_persist_session_cookies_ = false;

62
libcef/browser/browser_host_impl.cc
View File

@@ -591,7 +591,7 @@ void CefBrowserHostImpl::CloseBrowser(bool force_close) {
}
content::WebContents* contents = web_contents();
if (contents && contents->NeedToFireBeforeUnload()) {
if (contents && contents->NeedToFireBeforeUnloadOrUnload()) {
// Will result in a call to BeforeUnloadFired() and, if the close isn't
// canceled, CloseContents().
contents->DispatchBeforeUnload(false /* auto_cancel */);
@@ -763,8 +763,9 @@ void CefBrowserHostImpl::DownloadImage(
return;
web_contents()->DownloadImage(
gurl, is_favicon, max_image_size * gfx::ImageSkia::GetMaxSupportedScale(),
bypass_cache, base::BindOnce(OnDownloadImage, max_image_size, callback));
gurl, is_favicon, max_image_size,
max_image_size * gfx::ImageSkia::GetMaxSupportedScale(), bypass_cache,
base::BindOnce(OnDownloadImage, max_image_size, callback));
}
void CefBrowserHostImpl::Print() {
@@ -1639,30 +1640,6 @@ void CefBrowserHostImpl::LoadMainFrameURL(const std::string& url,
}
}
void CefBrowserHostImpl::OnFrameFocused(CefRefPtr<CefFrameHostImpl> frame) {
DCHECK(frame);
CefRefPtr<CefFrameHostImpl> previous_frame;
{
base::AutoLock lock_scope(state_lock_);
previous_frame = focused_frame_;
if (frame->IsMain())
focused_frame_ = nullptr;
else
focused_frame_ = frame;
}
if (!previous_frame) {
// The main frame is focused by default.
previous_frame = browser_info_->GetMainFrame();
}
if (previous_frame->GetIdentifier() != frame->GetIdentifier()) {
previous_frame->SetFocused(false);
frame->SetFocused(true);
}
}
void CefBrowserHostImpl::OnDidFinishLoad(CefRefPtr<CefFrameHostImpl> frame,
const GURL& validated_url,
int http_status_code) {
@@ -2108,8 +2085,7 @@ void CefBrowserHostImpl::LoadingStateChanged(content::WebContents* source,
}
}
void CefBrowserHostImpl::LoadProgressChanged(content::WebContents* source,
double progress) {
void CefBrowserHostImpl::LoadProgressChanged(double progress) {
if (client_.get()) {
CefRefPtr<CefDisplayHandler> handler = client_->GetDisplayHandler();
if (handler.get()) {
@@ -2740,6 +2716,34 @@ bool CefBrowserHostImpl::OnMessageReceived(
return false;
}
void CefBrowserHostImpl::OnFrameFocused(
content::RenderFrameHost* render_frame_host) {
CefRefPtr<CefFrameHostImpl> frame =
static_cast<CefFrameHostImpl*>(GetFrameForHost(render_frame_host).get());
if (!frame || frame->IsFocused())
return;
CefRefPtr<CefFrameHostImpl> previous_frame;
{
base::AutoLock lock_scope(state_lock_);
previous_frame = focused_frame_;
if (frame->IsMain())
focused_frame_ = nullptr;
else
focused_frame_ = frame;
}
if (!previous_frame) {
// The main frame is focused by default.
previous_frame = browser_info_->GetMainFrame();
}
if (previous_frame->GetIdentifier() != frame->GetIdentifier()) {
previous_frame->SetFocused(false);
frame->SetFocused(true);
}
}
void CefBrowserHostImpl::AccessibilityEventReceived(
const content::AXEventNotificationDetails& content_event_bundle) {
// Only needed in windowless mode.

5
libcef/browser/browser_host_impl.h
View File

@@ -313,7 +313,6 @@ class CefBrowserHostImpl : public CefBrowserHost,
const std::string& extra_headers);
// Called from CefFrameHostImpl.
void OnFrameFocused(CefRefPtr<CefFrameHostImpl> frame);
void OnDidFinishLoad(CefRefPtr<CefFrameHostImpl> frame,
const GURL& validated_url,
int http_status_code);
@@ -386,8 +385,7 @@ class CefBrowserHostImpl : public CefBrowserHost,
bool* was_blocked) override;
void LoadingStateChanged(content::WebContents* source,
bool to_different_document) override;
void LoadProgressChanged(content::WebContents* source,
double progress) override;
void LoadProgressChanged(double progress) override;
void CloseContents(content::WebContents* source) override;
void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
bool DidAddMessageToConsole(content::WebContents* source,
@@ -493,6 +491,7 @@ class CefBrowserHostImpl : public CefBrowserHost,
bool OnMessageReceived(const IPC::Message& message) override;
bool OnMessageReceived(const IPC::Message& message,
content::RenderFrameHost* render_frame_host) override;
void OnFrameFocused(content::RenderFrameHost* render_frame_host) override;
void AccessibilityEventReceived(
const content::AXEventNotificationDetails& content_event_bundle) override;
void AccessibilityLocationChangesReceived(

4
libcef/browser/browser_main.cc
View File

@@ -71,7 +71,7 @@
#include "libcef/browser/printing/print_dialog_linux.h"
#endif
#if defined(OS_MACOSX)
#if defined(OS_MACOSX) || defined(OS_WIN)
#include "chrome/browser/browser_process.h"
#include "components/os_crypt/os_crypt.h"
#endif
@@ -122,7 +122,7 @@ void CefBrowserMainParts::PreMainMessageLoopStart() {
ui::TouchFactory::SetTouchDeviceListFromCommandLine();
#endif
#if defined(OS_MACOSX)
#if defined(OS_MACOSX) || defined(OS_WIN)
// Initialize the OSCrypt.
PrefService* local_state = g_browser_process->local_state();
DCHECK(local_state);

141
libcef/browser/content_browser_client.cc
View File

@@ -39,7 +39,6 @@
#include "libcef/common/net/scheme_registration.h"
#include "libcef/common/request_impl.h"
#include "libcef/common/service_manifests/cef_content_browser_overlay_manifest.h"
#include "libcef/common/service_manifests/cef_content_renderer_overlay_manifest.h"
#include "base/base_switches.h"
#include "base/command_line.h"
@@ -103,7 +102,6 @@
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/browser/guest_view/extensions_guest_view_message_filter.h"
#include "extensions/browser/guest_view/web_view/web_view_guest.h"
#include "extensions/browser/io_thread_extension_message_filter.h"
#include "extensions/common/constants.h"
#include "extensions/common/switches.h"
#include "mojo/public/cpp/bindings/remote.h"
@@ -137,14 +135,20 @@
#endif
#if defined(OS_MACOSX)
#include "net/ssl/client_cert_store_mac.h"
#include "services/audio/public/mojom/constants.mojom.h"
#include "services/video_capture/public/mojom/constants.mojom.h"
#endif
#if defined(OS_WIN)
#include "net/ssl/client_cert_store_win.h"
#include "sandbox/win/src/sandbox_policy.h"
#endif
#if defined(USE_NSS_CERTS)
#include "net/ssl/client_cert_store_nss.h"
#endif
#if BUILDFLAG(HAS_SPELLCHECK_PANEL)
#include "chrome/browser/spellchecker/spell_check_panel_host_impl.h"
#endif
@@ -204,21 +208,22 @@ class CefQuotaCallbackImpl : public CefRequestCallback {
class CefAllowCertificateErrorCallbackImpl : public CefRequestCallback {
public:
typedef base::Callback<void(content::CertificateRequestResultType)>
typedef base::OnceCallback<void(content::CertificateRequestResultType)>
CallbackType;
explicit CefAllowCertificateErrorCallbackImpl(const CallbackType& callback)
: callback_(callback) {}
explicit CefAllowCertificateErrorCallbackImpl(CallbackType callback)
: callback_(std::move(callback)) {}
~CefAllowCertificateErrorCallbackImpl() {
if (!callback_.is_null()) {
// The callback is still pending. Cancel it now.
if (CEF_CURRENTLY_ON_UIT()) {
RunNow(callback_, false);
RunNow(std::move(callback_), false);
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefAllowCertificateErrorCallbackImpl::RunNow,
callback_, false));
CEF_POST_TASK(
CEF_UIT,
base::BindOnce(&CefAllowCertificateErrorCallbackImpl::RunNow,
std::move(callback_), false));
}
}
}
@@ -226,8 +231,7 @@ class CefAllowCertificateErrorCallbackImpl : public CefRequestCallback {
void Continue(bool allow) override {
if (CEF_CURRENTLY_ON_UIT()) {
if (!callback_.is_null()) {
RunNow(callback_, allow);
callback_.Reset();
RunNow(std::move(callback_), allow);
}
} else {
CEF_POST_TASK(CEF_UIT,
@@ -238,13 +242,14 @@ class CefAllowCertificateErrorCallbackImpl : public CefRequestCallback {
void Cancel() override { Continue(false); }
void Disconnect() { callback_.Reset(); }
CallbackType Disconnect() WARN_UNUSED_RESULT { return std::move(callback_); }
private:
static void RunNow(const CallbackType& callback, bool allow) {
static void RunNow(CallbackType callback, bool allow) {
CEF_REQUIRE_UIT();
callback.Run(allow ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE
: content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
std::move(callback).Run(
allow ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE
: content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
}
CallbackType callback_;
@@ -535,7 +540,6 @@ void CefContentBrowserClient::RenderProcessWillLaunch(
if (extensions::ExtensionsEnabled()) {
host->AddFilter(new extensions::ExtensionMessageFilter(id, profile));
host->AddFilter(new extensions::IOThreadExtensionMessageFilter());
host->AddFilter(
new extensions::ExtensionsGuestViewMessageFilter(id, profile));
}
@@ -713,8 +717,6 @@ base::Optional<service_manager::Manifest>
CefContentBrowserClient::GetServiceManifestOverlay(base::StringPiece name) {
if (name == content::mojom::kBrowserServiceName) {
return GetCefContentBrowserOverlayManifest();
} else if (name == content::mojom::kRendererServiceName) {
return GetCefContentRendererOverlayManifest();
}
return base::nullopt;
@@ -889,7 +891,7 @@ void CefContentBrowserClient::GetQuotaSettings(
const base::FilePath& cache_path = partition->GetPath();
storage::GetNominalDynamicSettings(
cache_path, cache_path.empty() /* is_incognito */,
storage::GetDefaultDiskInfoHelper(), std::move(callback));
storage::GetDefaultDeviceInfoHelper(), std::move(callback));
}
content::MediaObserver* CefContentBrowserClient::GetMediaObserver() {
@@ -924,15 +926,14 @@ void CefContentBrowserClient::AllowCertificateError(
const GURL& request_url,
bool is_main_frame_request,
bool strict_enforcement,
const base::Callback<void(content::CertificateRequestResultType)>&
callback) {
base::OnceCallback<void(content::CertificateRequestResultType)> callback) {
CEF_REQUIRE_UIT();
if (!is_main_frame_request) {
// A sub-resource has a certificate error. The user doesn't really
// have a context for making the right decision, so block the request
// hard.
callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
return;
}
@@ -950,14 +951,17 @@ void CefContentBrowserClient::AllowCertificateError(
CefRefPtr<CefSSLInfo> cef_ssl_info = new CefSSLInfoImpl(ssl_info);
CefRefPtr<CefAllowCertificateErrorCallbackImpl> callbackImpl(
new CefAllowCertificateErrorCallbackImpl(callback));
new CefAllowCertificateErrorCallbackImpl(std::move(callback)));
bool proceed = handler->OnCertificateError(
browser.get(), static_cast<cef_errorcode_t>(cert_error),
request_url.spec(), cef_ssl_info, callbackImpl.get());
if (!proceed) {
callbackImpl->Disconnect();
callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
// |callback| may be null if the user executed it despite returning false.
callback = callbackImpl->Disconnect();
if (!callback.is_null()) {
std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
}
}
}
@@ -1164,11 +1168,19 @@ void CefContentBrowserClient::ExposeInterfacesToRenderer(
std::unique_ptr<net::ClientCertStore>
CefContentBrowserClient::CreateClientCertStore(
content::ResourceContext* resource_context) {
if (!resource_context)
return nullptr;
return static_cast<CefResourceContext*>(resource_context)
->CreateClientCertStore();
content::BrowserContext* browser_context) {
// Match the logic in ProfileNetworkContextService::CreateClientCertStore.
#if defined(USE_NSS_CERTS)
// TODO: Add support for client implementation of crypto password dialog.
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
net::ClientCertStoreNSS::PasswordDelegateFactory()));
#elif defined(OS_WIN)
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
#elif defined(OS_MACOSX)
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
#else
#error Unknown platform.
#endif
}
std::unique_ptr<content::LoginDelegate>
@@ -1257,10 +1269,12 @@ bool CefContentBrowserClient::WillCreateURLLoaderFactory(
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
base::Optional<int64_t> navigation_id,
mojo::PendingReceiver<network::mojom::URLLoaderFactory>* factory_receiver,
mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
header_client,
bool* bypass_redirect_checks) {
bool* bypass_redirect_checks,
network::mojom::URLLoaderFactoryOverridePtr* factory_override) {
auto request_handler = net_service::CreateInterceptedRequestHandler(
browser_context, frame, render_process_id,
type == URLLoaderFactoryType::kNavigation,
@@ -1322,14 +1336,14 @@ CefContentBrowserClient::GetNetworkContextsParentDirectory() {
bool CefContentBrowserClient::HandleExternalProtocol(
const GURL& url,
base::Callback<content::WebContents*(void)> web_contents_getter,
base::OnceCallback<content::WebContents*()> web_contents_getter,
int child_id,
content::NavigationUIData* navigation_data,
bool is_main_frame,
ui::PageTransition page_transition,
bool has_user_gesture,
const base::Optional<url::Origin>& initiating_origin,
network::mojom::URLLoaderFactoryPtr* out_factory) {
mojo::PendingRemote<network::mojom::URLLoaderFactory>* out_factory) {
// Call the other HandleExternalProtocol variant.
return false;
}
@@ -1339,32 +1353,34 @@ bool CefContentBrowserClient::HandleExternalProtocol(
int frame_tree_node_id,
content::NavigationUIData* navigation_data,
const network::ResourceRequest& resource_request,
network::mojom::URLLoaderFactoryPtr* out_factory) {
auto request = mojo::MakeRequest(out_factory);
mojo::PendingRemote<network::mojom::URLLoaderFactory>* out_factory) {
mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver =
out_factory->InitWithNewPipeAndPassReceiver();
// CefBrowserPlatformDelegate::HandleExternalProtocol may be called if
// nothing handles the request.
if (CEF_CURRENTLY_ON_IOT()) {
auto request_handler = net_service::CreateInterceptedRequestHandler(
web_contents_getter, frame_tree_node_id, resource_request);
net_service::ProxyURLLoaderFactory::CreateProxy(
web_contents_getter, std::move(request), std::move(request_handler));
web_contents_getter, std::move(receiver), std::move(request_handler));
} else {
auto request_handler = net_service::CreateInterceptedRequestHandler(
web_contents_getter, frame_tree_node_id, resource_request);
CEF_POST_TASK(CEF_IOT,
base::BindOnce(
[](network::mojom::URLLoaderFactoryRequest request,
std::unique_ptr<net_service::InterceptedRequestHandler>
request_handler,
content::WebContents::Getter web_contents_getter) {
// Manages its own lifetime.
CEF_POST_TASK(
CEF_IOT,
base::BindOnce(
[](mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver,
std::unique_ptr<net_service::InterceptedRequestHandler>
request_handler,
content::WebContents::Getter web_contents_getter) {
// Manages its own lifetime.
net_service::ProxyURLLoaderFactory::CreateProxy(
web_contents_getter, std::move(request),
std::move(request_handler));
},
std::move(request), std::move(request_handler),
std::move(web_contents_getter)));
net_service::ProxyURLLoaderFactory::CreateProxy(
web_contents_getter, std::move(receiver),
std::move(request_handler));
},
std::move(receiver), std::move(request_handler),
std::move(web_contents_getter)));
}
return true;
}
@@ -1381,6 +1397,33 @@ CefContentBrowserClient::CreateWindowForPictureInPicture(
return content::OverlayWindow::Create(controller);
}
void CefContentBrowserClient::RegisterBrowserInterfaceBindersForFrame(
content::RenderFrameHost* render_frame_host,
service_manager::BinderMapWithContext<content::RenderFrameHost*>* map) {
if (!extensions::ExtensionsEnabled())
return;
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(render_frame_host);
if (!web_contents)
return;
const GURL& site = render_frame_host->GetSiteInstance()->GetSiteURL();
if (!site.SchemeIs(extensions::kExtensionScheme))
return;
content::BrowserContext* browser_context =
render_frame_host->GetProcess()->GetBrowserContext();
auto* extension = extensions::ExtensionRegistry::Get(browser_context)
->enabled_extensions()
.GetByID(site.host());
if (!extension)
return;
extensions::ExtensionsBrowserClient::Get()
->RegisterBrowserInterfaceBindersForFrame(map, render_frame_host,
extension);
}
std::string CefContentBrowserClient::GetProduct() {
// Match the logic in chrome_content_browser_client.cc GetProduct().
return ::GetProduct();

22
libcef/browser/content_browser_client.h
View File

@@ -89,8 +89,8 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
const GURL& request_url,
bool is_main_frame_request,
bool strict_enforcement,
const base::Callback<void(content::CertificateRequestResultType)>&
callback) override;
base::OnceCallback<void(content::CertificateRequestResultType)> callback)
override;
base::OnceClosure SelectClientCertificate(
content::WebContents* web_contents,
net::SSLCertRequestInfo* cert_request_info,
@@ -144,7 +144,7 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
blink::AssociatedInterfaceRegistry* associated_registry,
content::RenderProcessHost* render_process_host) override;
std::unique_ptr<net::ClientCertStore> CreateClientCertStore(
content::ResourceContext* resource_context) override;
content::BrowserContext* browser_context) override;
std::unique_ptr<content::LoginDelegate> CreateLoginDelegate(
const net::AuthChallengeInfo& auth_info,
content::WebContents* web_contents,
@@ -167,10 +167,12 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
base::Optional<int64_t> navigation_id,
mojo::PendingReceiver<network::mojom::URLLoaderFactory>* factory_receiver,
mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
header_client,
bool* bypass_redirect_checks) override;
bool* bypass_redirect_checks,
network::mojom::URLLoaderFactoryOverridePtr* factory_override) override;
void OnNetworkServiceCreated(
network::mojom::NetworkService* network_service) override;
mojo::Remote<network::mojom::NetworkContext> CreateNetworkContext(
@@ -180,22 +182,28 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
std::vector<base::FilePath> GetNetworkContextsParentDirectory() override;
bool HandleExternalProtocol(
const GURL& url,
base::Callback<content::WebContents*(void)> web_contents_getter,
base::OnceCallback<content::WebContents*()> web_contents_getter,
int child_id,
content::NavigationUIData* navigation_data,
bool is_main_frame,
ui::PageTransition page_transition,
bool has_user_gesture,
const base::Optional<url::Origin>& initiating_origin,
network::mojom::URLLoaderFactoryPtr* out_factory) override;
mojo::PendingRemote<network::mojom::URLLoaderFactory>* out_factory)
override;
bool HandleExternalProtocol(
content::WebContents::Getter web_contents_getter,
int frame_tree_node_id,
content::NavigationUIData* navigation_data,
const network::ResourceRequest& request,
network::mojom::URLLoaderFactoryPtr* out_factory) override;
mojo::PendingRemote<network::mojom::URLLoaderFactory>* out_factory)
override;
std::unique_ptr<content::OverlayWindow> CreateWindowForPictureInPicture(
content::PictureInPictureWindowController* controller) override;
void RegisterBrowserInterfaceBindersForFrame(
content::RenderFrameHost* render_frame_host,
service_manager::BinderMapWithContext<content::RenderFrameHost*>* map)
override;
std::string GetProduct() override;
std::string GetChromeProduct() override;

2
libcef/browser/context_menu_params_impl.cc
View File

@@ -38,7 +38,7 @@ CefContextMenuParamsImpl::TypeFlags CefContextMenuParamsImpl::GetTypeFlags() {
type_flags |= CM_TYPEFLAG_FRAME;
if (!params.link_url.is_empty())
type_flags |= CM_TYPEFLAG_LINK;
if (params.media_type != blink::WebContextMenuData::kMediaTypeNone)
if (params.media_type != blink::ContextMenuDataMediaType::kNone)
type_flags |= CM_TYPEFLAG_MEDIA;
if (!params.selection_text.empty())
type_flags |= CM_TYPEFLAG_SELECTION;

19
libcef/browser/extensions/component_extension_resource_manager.cc
View File

@@ -50,13 +50,28 @@ CefComponentExtensionResourceManager::GetTemplateReplacementsForExtension(
void CefComponentExtensionResourceManager::AddComponentResourceEntries(
const GritResourceMap* entries,
size_t size) {
base::FilePath gen_folder_path = base::FilePath().AppendASCII(
"@out_folder@/gen/chrome/browser/resources/");
gen_folder_path = gen_folder_path.NormalizePathSeparators();
for (size_t i = 0; i < size; ++i) {
base::FilePath resource_path =
base::FilePath().AppendASCII(entries[i].name);
resource_path = resource_path.NormalizePathSeparators();
DCHECK(!base::Contains(path_to_resource_info_, resource_path));
path_to_resource_info_[resource_path] = entries[i].value;
if (!gen_folder_path.IsParent(resource_path)) {
DCHECK(!base::Contains(path_to_resource_info_, resource_path));
path_to_resource_info_[resource_path] = entries[i].value;
} else {
// If the resource is a generated file, strip the generated folder's path,
// so that it can be served from a normal URL (as if it were not
// generated).
base::FilePath effective_path =
base::FilePath().AppendASCII(resource_path.AsUTF8Unsafe().substr(
gen_folder_path.value().length()));
DCHECK(!base::Contains(path_to_resource_info_, effective_path));
path_to_resource_info_[effective_path] = entries[i].value;
}
}
}

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

@@ -59,10 +59,6 @@ bool CefExtensionHostDelegate::CheckMediaAccessPermission(
return false;
}
ExtensionHostQueue* CefExtensionHostDelegate::GetExtensionHostQueue() const {
return CefExtensionsBrowserClient::Get()->GetExtensionHostQueue();
}
content::PictureInPictureResult CefExtensionHostDelegate::EnterPictureInPicture(
content::WebContents* web_contents,
const viz::SurfaceId& surface_id,

1
libcef/browser/extensions/extension_host_delegate.h
View File

@@ -34,7 +34,6 @@ class CefExtensionHostDelegate : public ExtensionHostDelegate {
const GURL& security_origin,
blink::mojom::MediaStreamType type,
const Extension* extension) override;
ExtensionHostQueue* GetExtensionHostQueue() const override;
content::PictureInPictureResult EnterPictureInPicture(
content::WebContents* web_contents,
const viz::SurfaceId& surface_id,

62
libcef/browser/extensions/extensions_browser_client.cc
View File

@@ -24,14 +24,17 @@
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_frame_host.h"
#include "extensions/browser/api/extensions_api_client.h"
#include "extensions/browser/api/mime_handler_private/mime_handler_private.h"
#include "extensions/browser/api/runtime/runtime_api_delegate.h"
#include "extensions/browser/app_sorting.h"
#include "extensions/browser/core_extensions_browser_api_provider.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/extension_host_delegate.h"
#include "extensions/browser/extensions_browser_interface_binders.h"
#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
#include "extensions/browser/mojo/interface_registration.h"
#include "extensions/browser/serial_extension_host_queue.h"
#include "extensions/browser/url_request_util.h"
#include "extensions/common/api/mime_handler.mojom.h"
#include "extensions/common/constants.h"
using content::BrowserContext;
@@ -39,6 +42,41 @@ using content::BrowserThread;
namespace extensions {
namespace {
void BindMimeHandlerService(
content::RenderFrameHost* frame_host,
mojo::PendingReceiver<extensions::mime_handler::MimeHandlerService>
receiver) {
auto* web_contents = content::WebContents::FromRenderFrameHost(frame_host);
if (!web_contents)
return;
auto* guest_view =
extensions::MimeHandlerViewGuest::FromWebContents(web_contents);
if (!guest_view)
return;
extensions::MimeHandlerServiceImpl::Create(guest_view->GetStreamWeakPtr(),
std::move(receiver));
}
void BindBeforeUnloadControl(
content::RenderFrameHost* frame_host,
mojo::PendingReceiver<extensions::mime_handler::BeforeUnloadControl>
receiver) {
auto* web_contents = content::WebContents::FromRenderFrameHost(frame_host);
if (!web_contents)
return;
auto* guest_view =
extensions::MimeHandlerViewGuest::FromWebContents(web_contents);
if (!guest_view)
return;
guest_view->FuseBeforeUnloadControl(std::move(receiver));
}
} // namespace
CefExtensionsBrowserClient::CefExtensionsBrowserClient()
: api_client_(new CefExtensionsAPIClient),
resource_manager_(new CefComponentExtensionResourceManager) {
@@ -117,11 +155,11 @@ base::FilePath CefExtensionsBrowserClient::GetBundleResourcePath(
void CefExtensionsBrowserClient::LoadResourceFromResourceBundle(
const network::ResourceRequest& request,
network::mojom::URLLoaderRequest loader,
mojo::PendingReceiver<network::mojom::URLLoader> loader,
const base::FilePath& resource_relative_path,
const int resource_id,
const std::string& content_security_policy,
network::mojom::URLLoaderClientPtr client,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
bool send_cors_header) {
chrome_url_request_util::LoadResourceFromResourceBundle(
request, std::move(loader), resource_relative_path, resource_id,
@@ -257,6 +295,18 @@ CefExtensionsBrowserClient::GetExtensionSystemFactory() {
return CefExtensionSystemFactory::GetInstance();
}
void CefExtensionsBrowserClient::RegisterBrowserInterfaceBindersForFrame(
service_manager::BinderMapWithContext<content::RenderFrameHost*>* map,
content::RenderFrameHost* render_frame_host,
const Extension* extension) const {
PopulateExtensionFrameBinders(map, render_frame_host, extension);
map->Add<extensions::mime_handler::MimeHandlerService>(
base::BindRepeating(&BindMimeHandlerService));
map->Add<extensions::mime_handler::BeforeUnloadControl>(
base::BindRepeating(&BindBeforeUnloadControl));
}
void CefExtensionsBrowserClient::RegisterExtensionInterfaces(
service_manager::BinderRegistryWithArgs<content::RenderFrameHost*>*
registry,
@@ -323,10 +373,4 @@ std::string CefExtensionsBrowserClient::GetApplicationLocale() {
return g_browser_process->GetApplicationLocale();
}
ExtensionHostQueue* CefExtensionsBrowserClient::GetExtensionHostQueue() {
if (!extension_host_queue_)
extension_host_queue_.reset(new SerialExtensionHostQueue);
return extension_host_queue_.get();
}
} // namespace extensions

15
libcef/browser/extensions/extensions_browser_client.h
View File

@@ -11,7 +11,6 @@
namespace extensions {
class ExtensionHostQueue;
class ExtensionsAPIClient;
// An ExtensionsBrowserClient that supports a single content::BrowserContent
@@ -49,11 +48,11 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
int* resource_id) const override;
void LoadResourceFromResourceBundle(
const network::ResourceRequest& request,
network::mojom::URLLoaderRequest loader,
mojo::PendingReceiver<network::mojom::URLLoader> loader,
const base::FilePath& resource_relative_path,
const int resource_id,
const std::string& content_security_policy,
network::mojom::URLLoaderClientPtr client,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
bool send_cors_header) override;
bool AllowCrossRendererResourceLoad(const GURL& url,
content::ResourceType resource_type,
@@ -82,6 +81,11 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
bool IsAppModeForcedForApp(const ExtensionId& extension_id) override;
bool IsLoggedInAsPublicAccount() override;
ExtensionSystemProvider* GetExtensionSystemFactory() override;
void RegisterBrowserInterfaceBindersForFrame(
service_manager::BinderMapWithContext<content::RenderFrameHost*>*
binder_map,
content::RenderFrameHost* render_frame_host,
const Extension* extension) const override;
void RegisterExtensionInterfaces(service_manager::BinderRegistryWithArgs<
content::RenderFrameHost*>* registry,
content::RenderFrameHost* render_frame_host,
@@ -104,8 +108,6 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
bool IsLockScreenContext(content::BrowserContext* context) override;
std::string GetApplicationLocale() override;
ExtensionHostQueue* GetExtensionHostQueue();
private:
// Support for extension APIs.
std::unique_ptr<ExtensionsAPIClient> api_client_;
@@ -113,9 +115,6 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
// Resource manager used to supply resources from pak files.
std::unique_ptr<ComponentExtensionResourceManager> resource_manager_;
// Used to create deferred RenderViews for extensions.
std::unique_ptr<ExtensionHostQueue> extension_host_queue_;
DISALLOW_COPY_AND_ASSIGN(CefExtensionsBrowserClient);
};

11
libcef/browser/frame_host_impl.cc
View File

@@ -464,7 +464,6 @@ bool CefFrameHostImpl::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(CefFrameHostImpl, message)
IPC_MESSAGE_HANDLER(CefHostMsg_FrameAttached, OnAttached)
IPC_MESSAGE_HANDLER(CefHostMsg_FrameFocused, OnFocused)
IPC_MESSAGE_HANDLER(CefHostMsg_DidFinishLoad, OnDidFinishLoad)
IPC_MESSAGE_HANDLER(CefHostMsg_UpdateDraggableRegions,
OnUpdateDraggableRegions)
@@ -556,16 +555,6 @@ void CefFrameHostImpl::OnAttached() {
}
}
void CefFrameHostImpl::OnFocused() {
if (!IsFocused()) {
// Calls back to SetFocused(true) after updating state on the previously
// focused frame.
auto browser = GetBrowserHostImpl();
if (browser)
browser->OnFrameFocused(this);
}
}
void CefFrameHostImpl::OnDidFinishLoad(const GURL& validated_url,
int http_status_code) {
auto browser = GetBrowserHostImpl();

1
libcef/browser/frame_host_impl.h
View File

@@ -144,7 +144,6 @@ class CefFrameHostImpl : public CefFrame {
// OnMessageReceived message handlers.
void OnAttached();
void OnFocused();
void OnDidFinishLoad(const GURL& validated_url, int http_status_code);
void OnUpdateDraggableRegions(
const std::vector<Cef_DraggableRegion_Params>& regions);

2
libcef/browser/native/window_delegate_view.cc
View File

@@ -43,7 +43,7 @@ void CefWindowDelegateView::Init(gfx::AcceleratedWidget parent_widget,
// Set the WS_VISIBLE flag.
params.type = views::Widget::InitParams::TYPE_CONTROL;
// Don't set the WS_EX_COMPOSITED flag.
params.opacity = views::Widget::InitParams::OPAQUE_WINDOW;
params.opacity = views::Widget::InitParams::WindowOpacity::kOpaque;
// Tell Aura not to draw the window frame on resize.
params.remove_standard_frame = true;
// Cause WidgetDelegate::CanActivate to return true. See comments in

6
libcef/browser/net/chrome_scheme_handler.cc
View File

@@ -465,10 +465,10 @@ class CefURLDataSource : public content::URLDataSource {
std::string GetSource() override { return host_; }
void StartDataRequest(
const std::string& path,
const GURL& path,
const content::WebContents::Getter& wc_getter,
const content::URLDataSource::GotDataCallback& callback) override {
callback.Run(output_);
content::URLDataSource::GotDataCallback callback) override {
std::move(callback).Run(output_);
}
std::string GetMimeType(const std::string& path) override {

6
libcef/browser/net/devtools_scheme_handler.cc
View File

@@ -32,9 +32,9 @@ class Delegate : public InternalHandlerDelegate {
if (path.length() > 0)
path = path.substr(1);
action->string_piece =
content::DevToolsFrontendHost::GetFrontendResource(path);
return !action->string_piece.empty();
action->bytes =
content::DevToolsFrontendHost::GetFrontendResourceBytes(path);
return !!action->bytes;
}
};

16
libcef/browser/net/internal_scheme_handler.cc
View File

@@ -157,21 +157,21 @@ class InternalHandlerFactory : public CefSchemeHandlerFactory {
if (action.mime_type.empty())
action.mime_type = GetMimeType(url.path());
if (action.string_piece.empty() && action.resource_id >= 0) {
action.string_piece = CefContentClient::Get()->GetDataResource(
action.resource_id, ui::SCALE_FACTOR_NONE);
if (action.string_piece.empty()) {
if (!action.bytes && action.resource_id >= 0) {
action.bytes =
CefContentClient::Get()->GetDataResourceBytes(action.resource_id);
if (!action.bytes) {
NOTREACHED() << "Failed to load internal resource for id: "
<< action.resource_id << " URL: " << url.spec().c_str();
return nullptr;
}
}
if (!action.string_piece.empty()) {
if (action.bytes) {
action.stream = CefStreamReader::CreateForData(
const_cast<char*>(action.string_piece.data()),
action.string_piece.size());
action.stream_size = action.string_piece.size();
const_cast<unsigned char*>(action.bytes->data()),
action.bytes->size());
action.stream_size = action.bytes->size();
}
if (action.stream.get()) {

6
libcef/browser/net/internal_scheme_handler.h
View File

@@ -10,7 +10,7 @@
#include "include/cef_scheme.h"
#include "base/strings/string_piece.h"
#include "base/memory/ref_counted_memory.h"
#include "url/gurl.h"
namespace scheme {
@@ -31,8 +31,8 @@ class InternalHandlerDelegate {
CefRefPtr<CefStreamReader> stream;
int stream_size;
// Option 2: Provide a base::StringPiece for the resource contents.
base::StringPiece string_piece;
// Option 2: Provide a base::RefCountedMemory for the resource contents.
scoped_refptr<base::RefCountedMemory> bytes;
// Option 3: Specify a resource id to load static content.
int resource_id;

5
libcef/browser/net_service/cookie_helper.cc
View File

@@ -146,7 +146,8 @@ void LoadCookies(content::BrowserContext* browser_context,
CEF_REQUIRE_IOT();
if ((request.load_flags & net::LOAD_DO_NOT_SEND_COOKIES) ||
request.credentials_mode == network::mojom::CredentialsMode::kOmit) {
request.credentials_mode == network::mojom::CredentialsMode::kOmit ||
request.url.IsAboutBlank()) {
// Continue immediately without loading cookies.
std::move(done_callback).Run(0, {});
return;
@@ -174,7 +175,7 @@ void SaveCookies(content::BrowserContext* browser_context,
CEF_REQUIRE_IOT();
if (request.credentials_mode == network::mojom::CredentialsMode::kOmit ||
!head.headers ||
request.url.IsAboutBlank() || !head.headers ||
!head.headers->HasHeader(net_service::kHTTPSetCookieHeaderName)) {
// Continue immediately without saving cookies.
std::move(done_callback).Run(0, {});

33
libcef/browser/net_service/proxy_url_loader_factory.cc
View File

@@ -122,9 +122,9 @@ class InterceptedRequest : public network::mojom::URLLoader,
uint32_t options,
const network::ResourceRequest& request,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
network::mojom::URLLoaderRequest loader_request,
network::mojom::URLLoaderClientPtr client,
network::mojom::URLLoaderFactoryPtr target_factory);
mojo::PendingReceiver<network::mojom::URLLoader> loader_receiver,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
mojo::PendingRemote<network::mojom::URLLoaderFactory> target_factory);
~InterceptedRequest() override;
// Restart the request. This happens on initial start and after redirect.
@@ -312,15 +312,15 @@ InterceptedRequest::InterceptedRequest(
uint32_t options,
const network::ResourceRequest& request,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
network::mojom::URLLoaderRequest loader_request,
network::mojom::URLLoaderClientPtr client,
network::mojom::URLLoaderFactoryPtr target_factory)
mojo::PendingReceiver<network::mojom::URLLoader> loader_receiver,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
mojo::PendingRemote<network::mojom::URLLoaderFactory> target_factory)
: factory_(factory),
id_(id),
options_(options),
request_(request),
traffic_annotation_(traffic_annotation),
proxied_loader_binding_(this, std::move(loader_request)),
proxied_loader_binding_(this, std::move(loader_receiver)),
target_client_(std::move(client)),
proxied_client_binding_(this),
target_factory_(std::move(target_factory)),
@@ -685,7 +685,7 @@ void InterceptedRequest::ContinueAfterIntercept() {
uint32_t options = options_ | network::mojom::kURLLoadOptionUseHeaderClient;
target_factory_->CreateLoaderAndStart(
mojo::MakeRequest(&target_loader_), id_.routing_id(), id_.request_id(),
options, request_, std::move(proxied_client), traffic_annotation_);
options, request_, proxied_client.PassInterface(), traffic_annotation_);
}
}
@@ -1117,13 +1117,13 @@ void ProxyURLLoaderFactory::CreateProxy(
// static
ProxyURLLoaderFactory* ProxyURLLoaderFactory::CreateProxy(
content::WebContents::Getter web_contents_getter,
network::mojom::URLLoaderFactoryRequest loader_request,
mojo::PendingReceiver<network::mojom::URLLoaderFactory> loader_receiver,
std::unique_ptr<InterceptedRequestHandler> request_handler) {
CEF_REQUIRE_IOT();
DCHECK(request_handler);
auto proxy = new ProxyURLLoaderFactory(
std::move(loader_request), nullptr,
std::move(loader_receiver), nullptr,
mojo::PendingReceiver<network::mojom::TrustedURLLoaderHeaderClient>(),
std::move(request_handler));
CEF_POST_TASK(CEF_UIT,
@@ -1133,12 +1133,12 @@ ProxyURLLoaderFactory* ProxyURLLoaderFactory::CreateProxy(
}
void ProxyURLLoaderFactory::CreateLoaderAndStart(
network::mojom::URLLoaderRequest loader,
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
int32_t routing_id,
int32_t request_id,
uint32_t options,
const network::ResourceRequest& request,
network::mojom::URLLoaderClientPtr client,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation) {
CEF_REQUIRE_IOT();
if (!CONTEXT_STATE_VALID()) {
@@ -1150,18 +1150,19 @@ void ProxyURLLoaderFactory::CreateLoaderAndStart(
if (pass_through) {
// This is the so-called pass-through, no-op option.
target_factory_->CreateLoaderAndStart(
std::move(loader), routing_id, request_id, options, request,
std::move(receiver), routing_id, request_id, options, request,
std::move(client), traffic_annotation);
return;
}
network::mojom::URLLoaderFactoryPtr target_factory_clone;
mojo::PendingRemote<network::mojom::URLLoaderFactory> target_factory_clone;
if (target_factory_)
target_factory_->Clone(MakeRequest(&target_factory_clone));
target_factory_->Clone(
target_factory_clone.InitWithNewPipeAndPassReceiver());
InterceptedRequest* req = new InterceptedRequest(
this, RequestId(request_id, routing_id), options, request,
traffic_annotation, std::move(loader), std::move(client),
traffic_annotation, std::move(receiver), std::move(client),
std::move(target_factory_clone));
requests_.insert(std::make_pair(request_id, base::WrapUnique(req)));
req->Restart();

19
libcef/browser/net_service/proxy_url_loader_factory.h
View File

@@ -148,18 +148,19 @@ class ProxyURLLoaderFactory
// Create a proxy object on the IO thread.
static ProxyURLLoaderFactory* CreateProxy(
content::WebContents::Getter web_contents_getter,
network::mojom::URLLoaderFactoryRequest loader_request,
mojo::PendingReceiver<network::mojom::URLLoaderFactory> loader_request,
std::unique_ptr<InterceptedRequestHandler> request_handler);
// mojom::URLLoaderFactory methods:
void CreateLoaderAndStart(network::mojom::URLLoaderRequest loader,
int32_t routing_id,
int32_t request_id,
uint32_t options,
const network::ResourceRequest& request,
network::mojom::URLLoaderClientPtr client,
const net::MutableNetworkTrafficAnnotationTag&
traffic_annotation) override;
void CreateLoaderAndStart(
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
int32_t routing_id,
int32_t request_id,
uint32_t options,
const network::ResourceRequest& request,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation)
override;
void Clone(
mojo::PendingReceiver<network::mojom::URLLoaderFactory> factory) override;

8
libcef/browser/net_service/stream_reader_url_loader.cc
View File

@@ -668,7 +668,7 @@ void StreamReaderURLLoader::HeadersComplete(int orig_status_code,
void StreamReaderURLLoader::ContinueWithResponseHeaders(
int32_t result,
const base::Optional<std::string>& headers,
const GURL& redirect_url) {
const base::Optional<GURL>& redirect_url) {
if (result != net::OK) {
RequestComplete(result);
return;
@@ -687,13 +687,13 @@ void StreamReaderURLLoader::ContinueWithResponseHeaders(
DCHECK(client_.is_bound());
std::string location;
if (!redirect_url.is_empty() ||
pending_response_.headers->IsRedirect(&location)) {
const auto has_redirect_url = redirect_url && !redirect_url->is_empty();
if (has_redirect_url || pending_response_.headers->IsRedirect(&location)) {
pending_response_.encoded_data_length = header_length_;
pending_response_.content_length = pending_response_.encoded_body_length =
0;
const GURL new_location =
redirect_url.is_empty() ? request_.url.Resolve(location) : redirect_url;
has_redirect_url ? *redirect_url : request_.url.Resolve(location);
client_->OnReceiveRedirect(
MakeRedirectInfo(request_, pending_response_.headers.get(),
new_location,

2
libcef/browser/net_service/stream_reader_url_loader.h
View File

@@ -190,7 +190,7 @@ class StreamReaderURLLoader : public network::mojom::URLLoader {
void HeadersComplete(int status_code, int64_t expected_content_length);
void ContinueWithResponseHeaders(int32_t result,
const base::Optional<std::string>& headers,
const GURL& redirect_url);
const base::Optional<GURL>& redirect_url);
void SendBody();
void ReadMore();

7
libcef/browser/net_service/url_loader_factory_getter.cc
View File

@@ -62,8 +62,9 @@ scoped_refptr<URLLoaderFactoryGetter> URLLoaderFactoryGetter::Create(
should_proxy |= CefContentBrowserClient::Get()->WillCreateURLLoaderFactory(
browser_context, render_frame_host, render_process_id,
content::ContentBrowserClient::URLLoaderFactoryType::kDocumentSubResource,
url::Origin(), &maybe_proxy_factory_request, nullptr /* header_client */,
nullptr /* bypass_redirect_checks */);
url::Origin(), base::nullopt /* navigation_id */,
&maybe_proxy_factory_request, nullptr /* header_client */,
nullptr /* bypass_redirect_checks */, nullptr /* factory_override */);
// If anyone above indicated that they care about proxying, pass the
// intermediate pipe along to the URLLoaderFactoryGetter.
@@ -107,7 +108,7 @@ URLLoaderFactoryGetter::GetURLLoaderFactory() {
}
URLLoaderFactoryGetter::URLLoaderFactoryGetter(
std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
std::unique_ptr<network::PendingSharedURLLoaderFactory> loader_factory_info,
network::mojom::URLLoaderFactoryPtrInfo proxy_factory_ptr_info,
network::mojom::URLLoaderFactoryRequest proxy_factory_request)
: loader_factory_info_(std::move(loader_factory_info)),

7
libcef/browser/net_service/url_loader_factory_getter.h
View File

@@ -19,7 +19,7 @@ class RenderFrameHost;
namespace network {
class SharedURLLoaderFactory;
class SharedURLLoaderFactoryInfo;
class PendingSharedURLLoaderFactory;
} // namespace network
namespace net_service {
@@ -49,14 +49,15 @@ class URLLoaderFactoryGetter
friend struct URLLoaderFactoryGetterDeleter;
URLLoaderFactoryGetter(
std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
std::unique_ptr<network::PendingSharedURLLoaderFactory>
loader_factory_info,
network::mojom::URLLoaderFactoryPtrInfo proxy_factory_ptr_info,
network::mojom::URLLoaderFactoryRequest proxy_factory_request);
~URLLoaderFactoryGetter();
void DeleteOnCorrectThread() const;
std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info_;
std::unique_ptr<network::PendingSharedURLLoaderFactory> loader_factory_info_;
scoped_refptr<network::SharedURLLoaderFactory> lazy_factory_;
network::mojom::URLLoaderFactoryPtrInfo proxy_factory_ptr_info_;
network::mojom::URLLoaderFactoryRequest proxy_factory_request_;

2
libcef/browser/osr/host_display_client_osr.cc
View File

@@ -9,7 +9,7 @@
#include "libcef/browser/browser_host_impl.h"
#include "libcef/browser/osr/render_widget_host_view_osr.h"
#include "base/memory/shared_memory.h"
#include "base/memory/shared_memory_mapping.h"
#include "components/viz/common/resources/resource_format.h"
#include "components/viz/common/resources/resource_sizes.h"
#include "mojo/public/cpp/system/platform_handle.h"

2
libcef/browser/osr/host_display_client_osr.h
View File

@@ -8,7 +8,7 @@
#include <memory>
#include "base/callback.h"
#include "base/memory/shared_memory.h"
#include "base/memory/shared_memory_mapping.h"
#include "components/viz/host/host_display_client.h"
#include "ui/gfx/native_widget_types.h"

51
libcef/browser/osr/render_widget_host_view_osr.cc
View File

@@ -29,7 +29,6 @@
#include "components/viz/common/switches.h"
#include "content/browser/bad_message.h"
#include "content/browser/compositor/image_transport_factory.h"
#include "content/browser/frame_host/render_widget_host_view_guest.h"
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/browser/renderer_host/cursor_manager.h"
#include "content/browser/renderer_host/delegated_frame_host.h"
@@ -157,8 +156,7 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
bool use_shared_texture,
bool use_external_begin_frame,
content::RenderWidgetHost* widget,
CefRenderWidgetHostViewOSR* parent_host_view,
bool is_guest_view_hack)
CefRenderWidgetHostViewOSR* parent_host_view)
: content::RenderWidgetHostViewBase(widget),
background_color_(background_color),
frame_rate_threshold_us_(0),
@@ -200,8 +198,7 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
// Matching the attributes from BrowserCompositorMac.
delegated_frame_host_ = std::make_unique<content::DelegatedFrameHost>(
AllocateFrameSinkId(is_guest_view_hack),
delegated_frame_host_client_.get(),
AllocateFrameSinkId(), delegated_frame_host_client_.get(),
false /* should_register_frame_sink_id */);
root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
@@ -416,8 +413,6 @@ void CefRenderWidgetHostViewOSR::TakeFallbackContentFrom(
content::RenderWidgetHostView* view) {
DCHECK(!static_cast<RenderWidgetHostViewBase*>(view)
->IsRenderWidgetHostViewChildFrame());
DCHECK(!static_cast<RenderWidgetHostViewBase*>(view)
->IsRenderWidgetHostViewGuest());
CefRenderWidgetHostViewOSR* view_cef =
static_cast<CefRenderWidgetHostViewOSR*>(view);
SetBackgroundColor(view_cef->background_color_);
@@ -512,18 +507,6 @@ void CefRenderWidgetHostViewOSR::InitAsFullscreen(
NOTREACHED() << "Fullscreen widgets are not supported in OSR";
}
// Called for the "platform view" created by WebContentsViewGuest and owned by
// RenderWidgetHostViewGuest.
void CefRenderWidgetHostViewOSR::InitAsGuest(
content::RenderWidgetHostView* parent_host_view,
content::RenderWidgetHostViewGuest* guest_view) {
DCHECK_EQ(parent_host_view_, parent_host_view);
DCHECK(browser_impl_);
parent_host_view_->AddGuestHostView(this);
parent_host_view_->RegisterGuestViewFrameSwappedCallback(guest_view);
}
void CefRenderWidgetHostViewOSR::UpdateCursor(
const content::WebCursor& cursor) {
TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::UpdateCursor");
@@ -1523,23 +1506,6 @@ void CefRenderWidgetHostViewOSR::RemoveGuestHostView(
guest_host_views_.erase(guest_host);
}
void CefRenderWidgetHostViewOSR::RegisterGuestViewFrameSwappedCallback(
content::RenderWidgetHostViewGuest* guest_host_view) {
guest_host_view->RegisterFrameSwappedCallback(base::BindOnce(
&CefRenderWidgetHostViewOSR::OnGuestViewFrameSwapped,
weak_ptr_factory_.GetWeakPtr(), base::Unretained(guest_host_view)));
guest_host_view->set_current_device_scale_factor(
current_device_scale_factor_);
}
void CefRenderWidgetHostViewOSR::OnGuestViewFrameSwapped(
content::RenderWidgetHostViewGuest* guest_host_view) {
InvalidateInternal(gfx::ConvertRectToPixel(current_device_scale_factor_,
guest_host_view->GetViewBounds()));
RegisterGuestViewFrameSwappedCallback(guest_host_view);
}
void CefRenderWidgetHostViewOSR::InvalidateInternal(
const gfx::Rect& bounds_in_pixels) {
if (video_consumer_) {
@@ -1578,17 +1544,8 @@ void CefRenderWidgetHostViewOSR::ImeCompositionRangeChanged(
}
}
viz::FrameSinkId CefRenderWidgetHostViewOSR::AllocateFrameSinkId(
bool is_guest_view_hack) {
// GuestViews have two RenderWidgetHostViews and so we need to make sure
// we don't have FrameSinkId collisions.
// The FrameSinkId generated here must be unique with FrameSinkId allocated
// in ContextFactoryPrivate.
content::ImageTransportFactory* factory =
content::ImageTransportFactory::GetInstance();
return is_guest_view_hack
? factory->GetContextFactoryPrivate()->AllocateFrameSinkId()
: render_widget_host_->GetFrameSinkId();
viz::FrameSinkId CefRenderWidgetHostViewOSR::AllocateFrameSinkId() {
return render_widget_host_->GetFrameSinkId();
}
void CefRenderWidgetHostViewOSR::UpdateBackgroundColorFromRenderer(

7
libcef/browser/osr/render_widget_host_view_osr.h
View File

@@ -102,8 +102,7 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
bool use_shared_texture,
bool use_external_begin_frame,
content::RenderWidgetHost* widget,
CefRenderWidgetHostViewOSR* parent_host_view,
bool is_guest_view_hack);
CefRenderWidgetHostViewOSR* parent_host_view);
~CefRenderWidgetHostViewOSR() override;
// RenderWidgetHostView implementation.
@@ -147,8 +146,6 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
const gfx::Rect& pos) override;
void InitAsFullscreen(
content::RenderWidgetHostView* reference_host_view) override;
void InitAsGuest(content::RenderWidgetHostView* parent_host_view,
content::RenderWidgetHostViewGuest* guest_view) override;
void UpdateCursor(const content::WebCursor& cursor) override;
void SetIsLoading(bool is_loading) override;
void RenderProcessGone() override;
@@ -297,7 +294,7 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
void RequestImeCompositionUpdate(bool start_monitoring);
viz::FrameSinkId AllocateFrameSinkId(bool is_guest_view_hack);
viz::FrameSinkId AllocateFrameSinkId();
void AddDamageRect(uint32_t sequence, const gfx::Rect& rect);

2
libcef/browser/osr/software_output_device_proxy.cc
View File

@@ -4,7 +4,7 @@
#include "cef/libcef/browser/osr/software_output_device_proxy.h"
#include "base/memory/shared_memory.h"
#include "base/memory/shared_memory_mapping.h"
#include "base/trace_event/trace_event.h"
#include "components/viz/common/resources/resource_sizes.h"
#include "mojo/public/cpp/base/shared_memory_utils.h"

12
libcef/browser/osr/video_consumer_osr.cc
View File

@@ -47,7 +47,8 @@ void CefVideoConsumerOSR::OnFrameCaptured(
base::ReadOnlySharedMemoryRegion data,
::media::mojom::VideoFrameInfoPtr info,
const gfx::Rect& content_rect,
viz::mojom::FrameSinkVideoConsumerFrameCallbacksPtr callbacks) {
mojo::PendingRemote<viz::mojom::FrameSinkVideoConsumerFrameCallbacks>
callbacks) {
const gfx::Size view_size = view_->SizeInPixels();
if (view_size != content_rect.size()) {
video_capturer_->SetResolutionConstraints(view_size, view_size, true);
@@ -55,18 +56,23 @@ void CefVideoConsumerOSR::OnFrameCaptured(
return;
}
mojo::Remote<viz::mojom::FrameSinkVideoConsumerFrameCallbacks>
callbacks_remote(std::move(callbacks));
if (!data.IsValid()) {
callbacks->Done();
callbacks_remote->Done();
return;
}
base::ReadOnlySharedMemoryMapping mapping = data.Map();
if (!mapping.IsValid()) {
DLOG(ERROR) << "Shared memory mapping failed.";
callbacks_remote->Done();
return;
}
if (mapping.size() <
media::VideoFrame::AllocationSize(info->pixel_format, info->coded_size)) {
DLOG(ERROR) << "Shared memory size was less than expected.";
callbacks_remote->Done();
return;
}
@@ -85,6 +91,8 @@ void CefVideoConsumerOSR::OnFrameCaptured(
}
view_->OnPaint(damage_rect, info->coded_size, pixels);
callbacks_remote->Done();
}
void CefVideoConsumerOSR::OnStopped() {}

4
libcef/browser/osr/video_consumer_osr.h
View File

@@ -4,6 +4,7 @@
#include "base/callback.h"
#include "base/memory/weak_ptr.h"
#include "components/viz/host/client_frame_sink_video_capturer.h"
#include "media/capture/mojom/video_capture_types.mojom.h"
class CefRenderWidgetHostViewOSR;
@@ -22,7 +23,8 @@ class CefVideoConsumerOSR : public viz::mojom::FrameSinkVideoConsumer {
base::ReadOnlySharedMemoryRegion data,
::media::mojom::VideoFrameInfoPtr info,
const gfx::Rect& content_rect,
viz::mojom::FrameSinkVideoConsumerFrameCallbacksPtr callbacks) override;
mojo::PendingRemote<viz::mojom::FrameSinkVideoConsumerFrameCallbacks>
callbacks) override;
void OnStopped() override;
CefRenderWidgetHostViewOSR* const view_;

19
libcef/browser/osr/web_contents_view_osr.cc
View File

@@ -11,7 +11,6 @@
#include "content/browser/browser_plugin/browser_plugin_embedder.h"
#include "content/browser/browser_plugin/browser_plugin_guest.h"
#include "content/browser/frame_host/render_widget_host_view_guest.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/browser/render_widget_host.h"
@@ -99,23 +98,15 @@ gfx::Rect CefWebContentsViewOSR::GetViewBounds() const {
void CefWebContentsViewOSR::CreateView(gfx::NativeView context) {}
content::RenderWidgetHostViewBase* CefWebContentsViewOSR::CreateViewForWidget(
content::RenderWidgetHost* render_widget_host,
content::RenderWidgetHost* embedder_render_widget_host) {
content::RenderWidgetHost* render_widget_host) {
if (render_widget_host->GetView()) {
return static_cast<content::RenderWidgetHostViewBase*>(
render_widget_host->GetView());
}
CefRenderWidgetHostViewOSR* embedder_host_view = nullptr;
if (embedder_render_widget_host) {
embedder_host_view = static_cast<CefRenderWidgetHostViewOSR*>(
embedder_render_widget_host->GetView());
}
const bool is_guest_view_hack = !!embedder_render_widget_host;
return new CefRenderWidgetHostViewOSR(
background_color_, use_shared_texture_, use_external_begin_frame_,
render_widget_host, embedder_host_view, is_guest_view_hack);
return new CefRenderWidgetHostViewOSR(background_color_, use_shared_texture_,
use_external_begin_frame_,
render_widget_host, nullptr);
}
// Called for popup and fullscreen widgets.
@@ -127,7 +118,7 @@ CefWebContentsViewOSR::CreateViewForChildWidget(
return new CefRenderWidgetHostViewOSR(background_color_, use_shared_texture_,
use_external_begin_frame_,
render_widget_host, view, false);
render_widget_host, view);
}
void CefWebContentsViewOSR::SetPageTitle(const base::string16& title) {}

3
libcef/browser/osr/web_contents_view_osr.h
View File

@@ -46,8 +46,7 @@ class CefWebContentsViewOSR : public content::WebContentsView,
gfx::Rect GetViewBounds() const override;
void CreateView(gfx::NativeView context) override;
content::RenderWidgetHostViewBase* CreateViewForWidget(
content::RenderWidgetHost* render_widget_host,
content::RenderWidgetHost* embedder_render_widget_host) override;
content::RenderWidgetHost* render_widget_host) override;
content::RenderWidgetHostViewBase* CreateViewForChildWidget(
content::RenderWidgetHost* render_widget_host) override;
void SetPageTitle(const base::string16& title) override;

9
libcef/browser/prefs/browser_prefs.cc
View File

@@ -23,10 +23,10 @@
#include "chrome/browser/net/system_network_context_manager.h"
#include "chrome/browser/plugins/plugin_info_host_impl.h"
#include "chrome/browser/prefs/chrome_command_line_pref_store.h"
#include "chrome/browser/printing/print_preview_sticky_settings.h"
#include "chrome/browser/renderer_host/pepper/device_id_fetcher.h"
#include "chrome/browser/ssl/ssl_config_service_manager.h"
#include "chrome/browser/themes/theme_service.h"
#include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
#include "chrome/common/buildflags.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/net/safe_search_util.h"
@@ -56,7 +56,7 @@
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/ui_base_switches.h"
#if defined(OS_MACOSX)
#if defined(OS_MACOSX) || defined(OS_WIN)
#include "components/os_crypt/os_crypt.h"
#endif
@@ -185,7 +185,7 @@ std::unique_ptr<PrefService> CreatePrefService(Profile* profile,
if (!profile) {
SystemNetworkContextManager::RegisterPrefs(registry.get());
#if defined(OS_MACOSX)
#if defined(OS_MACOSX) || defined(OS_WIN)
OSCrypt::RegisterLocalPrefs(registry.get());
#endif
}
@@ -244,7 +244,7 @@ std::unique_ptr<PrefService> CreatePrefService(Profile* profile,
registry->RegisterStringPref(
prefs::kPrintPreviewDefaultDestinationSelectionRules, std::string());
registry->RegisterBooleanPref(prefs::kCloudPrintSubmitEnabled, false);
printing::StickySettings::RegisterProfilePrefs(registry.get());
printing::PrintPreviewStickySettings::RegisterProfilePrefs(registry.get());
DownloadPrefs::RegisterProfilePrefs(registry.get());
// Cache preferences.
@@ -284,6 +284,7 @@ std::unique_ptr<PrefService> CreatePrefService(Profile* profile,
registry->SetDefaultPrefValue(language::prefs::kAcceptLanguages,
base::Value(accept_language_list));
}
registry->RegisterListPref(prefs::kWebRtcLocalIpsAllowedUrls);
}
// Build the PrefService that manages the PrefRegistry and PrefStores.

2
libcef/browser/printing/print_view_manager.cc
View File

@@ -209,7 +209,7 @@ bool CefPrintViewManager::PrintToPDF(content::RenderFrameHost* rfh,
print_render_frame_remote;
rfh->GetRemoteAssociatedInterfaces()->GetInterface(
&print_render_frame_remote);
print_render_frame_remote->InitiatePrintPreview(nullptr,
print_render_frame_remote->InitiatePrintPreview({},
!!settings.selection_only);
return true;

12
libcef/browser/request_context_impl.cc
View File

@@ -95,18 +95,20 @@ class ResolveHostHelper : public network::ResolveHostClientBase {
browser_context->GetNetworkContext()->CreateHostResolver(
base::nullopt, host_resolver_.BindNewPipeAndPassReceiver());
host_resolver_.set_disconnect_handler(
base::BindOnce(&ResolveHostHelper::OnComplete, base::Unretained(this),
net::ERR_FAILED, base::nullopt));
host_resolver_.set_disconnect_handler(base::BindOnce(
&ResolveHostHelper::OnComplete, base::Unretained(this), net::ERR_FAILED,
net::ResolveErrorInfo(net::ERR_FAILED), base::nullopt));
host_resolver_->ResolveHost(
net::HostPortPair::FromURL(GURL(origin.ToString())), nullptr,
net::HostPortPair::FromURL(GURL(origin.ToString())),
net::NetworkIsolationKey::Todo(), nullptr,
receiver_.BindNewPipeAndPassRemote());
}
private:
void OnComplete(
int result,
int32_t result,
const ::net::ResolveErrorInfo& resolve_error_info,
const base::Optional<net::AddressList>& resolved_addresses) override {
CEF_REQUIRE_UIT();

31
libcef/browser/resource_context.cc
View File

@@ -15,18 +15,6 @@
#include "content/browser/resource_context_impl.h"
#include "content/public/browser/browser_thread.h"
#if defined(USE_NSS_CERTS)
#include "net/ssl/client_cert_store_nss.h"
#endif
#if defined(OS_WIN)
#include "net/ssl/client_cert_store_win.h"
#endif
#if defined(OS_MACOSX)
#include "net/ssl/client_cert_store_mac.h"
#endif
CefResourceContext::CefResourceContext(bool is_off_the_record)
: is_off_the_record_(is_off_the_record) {
// Using base::Unretained() is safe because both this callback and possible
@@ -38,25 +26,6 @@ CefResourceContext::CefResourceContext(bool is_off_the_record)
CefResourceContext::~CefResourceContext() {}
std::unique_ptr<net::ClientCertStore>
CefResourceContext::CreateClientCertStore() {
#if defined(USE_NSS_CERTS)
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
net::ClientCertStoreNSS::PasswordDelegateFactory()));
#elif defined(OS_WIN)
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
#elif defined(OS_MACOSX)
return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
#elif defined(USE_OPENSSL)
// OpenSSL does not use the ClientCertStore infrastructure. On Android client
// cert matching is done by the OS as part of the call to show the cert
// selection dialog.
return std::unique_ptr<net::ClientCertStore>();
#else
#error Unknown platform.
#endif
}
void CefResourceContext::AddHandler(
int render_process_id,
int render_frame_id,

3
libcef/browser/resource_context.h
View File

@@ -13,7 +13,6 @@
#include "libcef/browser/request_context_handler_map.h"
#include "content/public/browser/resource_context.h"
#include "net/ssl/client_cert_store.h"
class GURL;
@@ -28,8 +27,6 @@ class CefResourceContext : public content::ResourceContext {
explicit CefResourceContext(bool is_off_the_record);
~CefResourceContext() override;
std::unique_ptr<net::ClientCertStore> CreateClientCertStore();
// See comments in CefRequestContextHandlerMap.
void AddHandler(int render_process_id,
int render_frame_id,

2
libcef/browser/ssl_host_state_delegate.cc
View File

@@ -62,7 +62,7 @@ void CefSSLHostStateDelegate::AllowCert(const std::string& host,
}
void CefSSLHostStateDelegate::Clear(
const base::Callback<bool(const std::string&)>& host_filter) {
const base::RepeatingCallback<bool(const std::string&)> host_filter) {
if (host_filter.is_null()) {
cert_policy_for_host_.clear();
return;

4
libcef/browser/ssl_host_state_delegate.h
View File

@@ -50,8 +50,8 @@ class CefSSLHostStateDelegate : public content::SSLHostStateDelegate {
void AllowCert(const std::string& host,
const net::X509Certificate& cert,
int error) override;
void Clear(
const base::Callback<bool(const std::string&)>& host_filter) override;
void Clear(const base::RepeatingCallback<bool(const std::string&)>
host_filter) override;
content::SSLHostStateDelegate::CertJudgment QueryPolicy(
const std::string& host,
const net::X509Certificate& cert,

8
libcef/browser/views/menu_button_view.cc
View File

@@ -51,10 +51,10 @@ void CefMenuButtonView::SetDrawStringsFlags(int flags) {
label()->SetDrawStringsFlags(flags);
}
void CefMenuButtonView::OnMenuButtonClicked(views::Button* source,
const gfx::Point& point,
const ui::Event* event) {
void CefMenuButtonView::ButtonPressed(views::Button* source,
const ui::Event& event) {
auto position = source->GetMenuPosition();
cef_delegate()->OnMenuButtonPressed(
GetCefMenuButton(), CefPoint(point.x(), point.y()),
GetCefMenuButton(), CefPoint(position.x(), position.y()),
new ButtonPressedLock(static_cast<views::MenuButton*>(source)));
}

11
libcef/browser/views/menu_button_view.h
View File

@@ -12,14 +12,11 @@
#include "libcef/browser/views/label_button_view.h"
#include "ui/views/controls/button/menu_button.h"
#include "ui/views/controls/button/menu_button_listener.h"
// Extend views::LabelButton with a no-argument constructor as required by the
// CefViewView template and extend views::ButtonListener as required by the
// CefButtonView template.
class MenuButtonEx : public views::MenuButton,
public views::ButtonListener,
public views::MenuButtonListener {
class MenuButtonEx : public views::MenuButton, public views::ButtonListener {
public:
MenuButtonEx() : views::MenuButton(base::string16(), this) {
// TODO(cef): MenuButton should not use ButtonListener. See
@@ -45,10 +42,8 @@ class CefMenuButtonView
// Set the flags that control display of accelerator characters.
void SetDrawStringsFlags(int flags);
// views::MenuButtonListener methods:
void OnMenuButtonClicked(views::Button* source,
const gfx::Point& point,
const ui::Event* event) override;
// views::ButtonListener methods:
void ButtonPressed(views::Button* source, const ui::Event& event) override;
private:
DISALLOW_COPY_AND_ASSIGN(CefMenuButtonView);