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 125.0.6422.0 (#1287751)

Browse Source
This commit is contained in:
Marshall Greenblatt
2024-04-23 16:06:00 -04:00
parent 4fe529e2dc
commit b67cbc47e3
145 changed files with 1047 additions and 920 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -452,6 +452,12 @@ void AlloyBrowserContext::RebuildTable(
enumerator->OnComplete(true);
}
void AlloyBrowserContext::BuildVisitedLinkTable(
const scoped_refptr<VisitedLinkEnumerator>& enumerator) {
// Called when visited links will not or cannot be loaded from disk.
enumerator->OnVisitedLinkComplete(true);
}
DownloadPrefs* AlloyBrowserContext::GetDownloadPrefs() {
CEF_REQUIRE_UIT();
if (!download_prefs_) {

2
libcef/browser/alloy/alloy_browser_context.h
View File

@@ -110,6 +110,8 @@ class AlloyBrowserContext : public ChromeProfileAlloy,
// visitedlink::VisitedLinkDelegate methods.
void RebuildTable(const scoped_refptr<URLEnumerator>& enumerator) override;
void BuildVisitedLinkTable(
const scoped_refptr<VisitedLinkEnumerator>& enumerator) override;
// Manages extensions.
extensions::CefExtensionSystem* extension_system() const {

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

@@ -618,7 +618,7 @@ bool AlloyBrowserHostImpl::MaybeAllowNavigation(
CEF_POST_TASK(CEF_UIT,
base::BindOnce(
base::IgnoreResult(&AlloyBrowserHostImpl::OpenURLFromTab),
this, nullptr, params));
this, nullptr, params, base::NullCallback()));
return false;
}
@@ -926,8 +926,11 @@ bool AlloyBrowserHostImpl::IsAudioMuted() {
content::WebContents* AlloyBrowserHostImpl::OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) {
auto target_contents = contents_delegate_->OpenURLFromTab(source, params);
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>
navigation_handle_callback) {
auto target_contents = contents_delegate_->OpenURLFromTabEx(
source, params, navigation_handle_callback);
if (target_contents) {
// Start a navigation in the current browser that will result in the
// creation of a new render process.
@@ -1282,6 +1285,12 @@ content::PreloadingEligibility AlloyBrowserHostImpl::IsPrerender2Supported(
return content::PreloadingEligibility::kEligible;
}
void AlloyBrowserHostImpl::DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) {
contents_delegate_->DraggableRegionsChanged(regions, contents);
}
// content::WebContentsObserver methods.
// -----------------------------------------------------------------------------

7
libcef/browser/alloy/alloy_browser_host_impl.h
View File

@@ -184,7 +184,9 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
// content::WebContentsDelegate methods.
content::WebContents* OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) override;
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>
navigation_handle_callback) override;
bool ShouldAllowRendererInitiatedCrossProcessNavigation(
bool is_main_frame_navigation) override;
void AddNewContents(content::WebContents* source,
@@ -279,6 +281,9 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
bool IsBackForwardCacheSupported() override;
content::PreloadingEligibility IsPrerender2Supported(
content::WebContents& web_contents) override;
void DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) override;
// content::WebContentsObserver methods.
using content::WebContentsObserver::BeforeUnloadFired;

3
libcef/browser/alloy/alloy_browser_main.h
View File

@@ -6,10 +6,11 @@
#define CEF_LIBCEF_BROWSER_ALLOY_ALLOY_BROWSER_MAIN_H_
#pragma once
#include <string_view>
#include "libcef/browser/request_context_impl.h"
#include "base/command_line.h"
#include "base/strings/string_piece.h"
#include "build/build_config.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/browser_main_parts.h"

12
libcef/browser/alloy/alloy_content_browser_client.cc
View File

@@ -92,6 +92,7 @@
#include "components/pdf/browser/pdf_navigation_throttle.h"
#include "components/pdf/browser/pdf_url_loader_request_interceptor.h"
#include "components/pdf/common/constants.h"
#include "components/pdf/common/pdf_util.h"
#include "components/policy/core/common/policy_pref_names.h"
#include "components/spellcheck/common/spellcheck.mojom.h"
#include "components/version_info/version_info.h"
@@ -449,7 +450,7 @@ bool AlloyContentBrowserClient::DoesSiteRequireDedicatedProcess(
}
bool AlloyContentBrowserClient::ShouldTreatURLSchemeAsFirstPartyWhenTopLevel(
base::StringPiece scheme,
std::string_view scheme,
bool is_embedded_origin_secure) {
// This is needed to bypass the normal SameSite rules for any chrome:// page
// embedding a secure origin, regardless of the registrable domains of any
@@ -470,7 +471,7 @@ bool AlloyContentBrowserClient::ShouldTreatURLSchemeAsFirstPartyWhenTopLevel(
bool AlloyContentBrowserClient::
ShouldIgnoreSameSiteCookieRestrictionsWhenTopLevel(
base::StringPiece scheme,
std::string_view scheme,
bool is_embedded_origin_secure) {
return is_embedded_origin_secure && scheme == content::kChromeUIScheme;
}
@@ -913,10 +914,10 @@ void AlloyContentBrowserClient::
},
&render_frame_host));
associated_registry.AddInterface<pdf::mojom::PdfService>(base::BindRepeating(
associated_registry.AddInterface<pdf::mojom::PdfHost>(base::BindRepeating(
[](content::RenderFrameHost* render_frame_host,
mojo::PendingAssociatedReceiver<pdf::mojom::PdfService> receiver) {
pdf::PDFDocumentHelper::BindPdfService(
mojo::PendingAssociatedReceiver<pdf::mojom::PdfHost> receiver) {
pdf::PDFDocumentHelper::BindPdfHost(
std::move(receiver), render_frame_host,
std::make_unique<ChromePDFDocumentHelperClient>());
},
@@ -1179,6 +1180,7 @@ void AlloyContentBrowserClient::WillCreateURLLoaderFactory(
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
const net::IsolationInfo& isolation_info,
std::optional<int64_t> navigation_id,
ukm::SourceIdObj ukm_source_id,
network::URLLoaderFactoryBuilder& factory_builder,

5
libcef/browser/alloy/alloy_content_browser_client.h
View File

@@ -45,10 +45,10 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
bool DoesSiteRequireDedicatedProcess(content::BrowserContext* browser_context,
const GURL& effective_site_url) override;
bool ShouldTreatURLSchemeAsFirstPartyWhenTopLevel(
base::StringPiece scheme,
std::string_view scheme,
bool is_embedded_origin_secure) override;
bool ShouldIgnoreSameSiteCookieRestrictionsWhenTopLevel(
base::StringPiece scheme,
std::string_view scheme,
bool is_embedded_origin_secure) override;
void OverrideURLLoaderFactoryParams(
content::BrowserContext* browser_context,
@@ -186,6 +186,7 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
const net::IsolationInfo& isolation_info,
std::optional<int64_t> navigation_id,
ukm::SourceIdObj ukm_source_id,
network::URLLoaderFactoryBuilder& factory_builder,

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

@@ -370,6 +370,12 @@ ChromeBrowserProcessAlloy::subresource_filter_ruleset_service() {
return nullptr;
}
subresource_filter::RulesetService*
ChromeBrowserProcessAlloy::fingerprinting_protection_ruleset_service() {
DCHECK(false);
return nullptr;
}
StartupData* ChromeBrowserProcessAlloy::startup_data() {
DCHECK(false);
return nullptr;

2
libcef/browser/alloy/chrome_browser_process_alloy.h
View File

@@ -92,6 +92,8 @@ class ChromeBrowserProcessAlloy : public BrowserProcess {
safe_browsing::SafeBrowsingService* safe_browsing_service() override;
subresource_filter::RulesetService* subresource_filter_ruleset_service()
override;
subresource_filter::RulesetService*
fingerprinting_protection_ruleset_service() override;
StartupData* startup_data() override;
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)

2
libcef/browser/alloy/devtools/devtools_file_manager.cc
View File

@@ -35,7 +35,7 @@ void WriteToFile(const base::FilePath& path, const std::string& content) {
void AppendToFile(const base::FilePath& path, const std::string& content) {
DCHECK(!path.empty());
base::AppendToFile(path, base::StringPiece(content));
base::AppendToFile(path, std::string_view(content));
}
} // namespace

12
libcef/browser/alloy/devtools/devtools_frontend.cc
View File

@@ -166,7 +166,7 @@ void LogProtocolMessage(const base::FilePath& log_file,
WriteTimestamp(stream);
stream << ": " << type_label << ": " << to_log << "\n";
const std::string& str = stream.str();
if (!base::AppendToFile(log_file, base::StringPiece(str))) {
if (!base::AppendToFile(log_file, std::string_view(str))) {
LOG(ERROR) << "Failed to write file " << log_file.value();
log_error = true;
}
@@ -200,7 +200,7 @@ class CefDevToolsFrontend::NetworkResourceLoader
response_headers_ = response_head.headers;
}
void OnDataReceived(base::StringPiece chunk,
void OnDataReceived(std::string_view chunk,
base::OnceClosure resume) override {
base::Value chunkValue;
@@ -577,8 +577,8 @@ void CefDevToolsFrontend::DispatchProtocolMessage(
return;
}
base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),
message.size());
std::string_view str_message(reinterpret_cast<const char*>(message.data()),
message.size());
if (ProtocolLoggingEnabled()) {
// Quick check to avoid parsing the JSON object. Events begin with a
// "method" value whereas method results begin with an "id" value.
@@ -595,7 +595,7 @@ void CefDevToolsFrontend::DispatchProtocolMessage(
size_t total_size = str_message.length();
for (size_t pos = 0; pos < str_message.length();
pos += kMaxMessageChunkSize) {
base::StringPiece str_message_chunk =
std::string_view str_message_chunk =
str_message.substr(pos, kMaxMessageChunkSize);
CallClientFunction(
@@ -643,7 +643,7 @@ bool CefDevToolsFrontend::ProtocolLoggingEnabled() const {
}
void CefDevToolsFrontend::LogProtocolMessage(ProtocolMessageType type,
const base::StringPiece& message) {
const std::string_view& message) {
DCHECK(ProtocolLoggingEnabled());
std::string to_log(message.substr(0, kMaxLogLineLength));

2
libcef/browser/alloy/devtools/devtools_frontend.h
View File

@@ -87,7 +87,7 @@ class CefDevToolsFrontend : public content::WebContentsObserver,
bool ProtocolLoggingEnabled() const;
void LogProtocolMessage(ProtocolMessageType type,
const base::StringPiece& message);
const std::string_view& message);
PrefService* GetPrefs() const;

39
libcef/browser/browser_contents_delegate.cc
View File

@@ -25,6 +25,7 @@
#include "services/network/public/mojom/url_response_head.mojom.h"
#include "third_party/blink/public/mojom/favicon/favicon_url.mojom.h"
#include "third_party/blink/public/mojom/input/focus_type.mojom-blink.h"
#include "third_party/blink/public/mojom/page/draggable_region.mojom.h"
#include "third_party/blink/public/mojom/widget/platform_widget.mojom-test-utils.h"
#if defined(OS_WIN)
@@ -112,9 +113,11 @@ void CefBrowserContentsDelegate::RemoveObserver(Observer* observer) {
// |source| may be NULL for navigations in the current tab, or if the
// navigation originates from a guest view via MaybeAllowNavigation.
content::WebContents* CefBrowserContentsDelegate::OpenURLFromTab(
content::WebContents* CefBrowserContentsDelegate::OpenURLFromTabEx(
content::WebContents* source,
const content::OpenURLParams& params) {
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>&
navigation_handle_callback) {
bool cancel = false;
if (auto c = client()) {
@@ -133,8 +136,13 @@ content::WebContents* CefBrowserContentsDelegate::OpenURLFromTab(
}
}
if (!cancel) {
// TODO: Do something with |navigation_handle_callback|.
return web_contents();
}
// Returning nullptr will cancel the navigation.
return cancel ? nullptr : web_contents();
return nullptr;
}
void CefBrowserContentsDelegate::LoadingStateChanged(
@@ -228,11 +236,9 @@ void CefBrowserContentsDelegate::CanDownload(
base::OnceCallback<void(bool)> callback) {
bool allow = true;
if (auto delegate = platform_delegate()) {
if (auto c = client()) {
if (auto handler = c->GetDownloadHandler()) {
allow = handler->CanDownload(browser(), url.spec(), request_method);
}
if (auto c = client()) {
if (auto handler = c->GetDownloadHandler()) {
allow = handler->CanDownload(browser(), url.spec(), request_method);
}
}
@@ -294,6 +300,23 @@ bool CefBrowserContentsDelegate::HandleKeyboardEvent(
return false;
}
void CefBrowserContentsDelegate::DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) {
// Already converted to window bounds in WebViewImpl::DraggableRegionsChanged.
std::vector<cef::mojom::DraggableRegionEntryPtr> cef_regions;
if (!regions.empty()) {
cef_regions.reserve(regions.size());
for (const auto& region : regions) {
auto cef_region = cef::mojom::DraggableRegionEntry::New(
region->bounds, region->draggable);
cef_regions.emplace_back(std::move(cef_region));
}
}
browser_info_->GetMainFrame()->UpdateDraggableRegions(std::move(cef_regions));
}
void CefBrowserContentsDelegate::RenderFrameCreated(
content::RenderFrameHost* render_frame_host) {
browser_info_->MaybeCreateFrame(render_frame_host, false /* is_guest_view */);

14
libcef/browser/browser_contents_delegate.h
View File

@@ -80,10 +80,15 @@ class CefBrowserContentsDelegate : public content::WebContentsDelegate,
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
// WebContentsDelegate methods:
content::WebContents* OpenURLFromTab(
// Same as OpenURLFromTab but only taking |navigation_handle_callback|
// if the return value is non-nullptr.
content::WebContents* OpenURLFromTabEx(
content::WebContents* source,
const content::OpenURLParams& params) override;
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>&
navigation_handle_callback);
// WebContentsDelegate methods:
void LoadingStateChanged(content::WebContents* source,
bool should_show_loading_ui) override;
void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
@@ -105,6 +110,9 @@ class CefBrowserContentsDelegate : public content::WebContentsDelegate,
bool HandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event) override;
void DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) override;
// WebContentsObserver methods:
void RenderFrameCreated(content::RenderFrameHost* render_frame_host) override;

19
libcef/browser/chrome/browser_delegate.h
View File

@@ -12,12 +12,17 @@
#include "base/memory/scoped_refptr.h"
#include "chrome/browser/ui/page_action/page_action_icon_type.h"
#include "content/public/browser/web_contents_delegate.h"
#include "third_party/blink/public/mojom/page/draggable_region.mojom-forward.h"
#include "third_party/skia/include/core/SkRegion.h"
#include "ui/base/window_open_disposition.h"
class Browser;
class Profile;
namespace content {
class NavigationHandle;
}
namespace cef {
// Delegate for the chrome Browser object. Lifespan is controlled by the Browser
@@ -151,16 +156,22 @@ class BrowserDelegate : public content::WebContentsDelegate {
return std::nullopt;
}
// Set the draggable region relative to web contents.
// Called from DraggableRegionsHostImpl::UpdateDraggableRegions.
virtual void UpdateDraggableRegion(const SkRegion& region) {}
// Called at the end of a fullscreen transition.
virtual void WindowFullscreenStateChanged() {}
// Returns true if this browser has a Views-hosted opener. Only
// applicable for Browsers of type picture_in_picture and devtools.
virtual bool HasViewsHostedOpener() const { return false; }
// Same as OpenURLFromTab but only taking |navigation_handle_callback|
// if the return value is non-nullptr.
virtual content::WebContents* OpenURLFromTabEx(
content::WebContents* source,
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>&
navigation_handle_callback) {
return nullptr;
}
};
} // namespace cef

35
libcef/browser/chrome/chrome_browser_delegate.cc
View File

@@ -2,10 +2,10 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include "libcef/browser/chrome/chrome_browser_delegate.h"
#include <memory>
#include "libcef/browser/browser_contents_delegate.h"
#include "libcef/browser/browser_host_base.h"
#include "libcef/browser/browser_info_manager.h"
@@ -22,12 +22,14 @@
#include "libcef/browser/views/window_impl.h"
#include "libcef/common/app_manager.h"
#include "libcef/common/frame_util.h"
#include "third_party/blink/public/mojom/page/draggable_region.mojom.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_tabstrip.h"
#include "content/public/browser/global_routing_id.h"
#include "content/public/browser/keyboard_event_processing_result.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/browser/render_widget_host.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/common/input/native_web_keyboard_event.h"
@@ -454,9 +456,23 @@ const std::optional<SkRegion> ChromeBrowserDelegate::GetDraggableRegion()
return draggable_region_;
}
void ChromeBrowserDelegate::UpdateDraggableRegion(const SkRegion& region) {
DCHECK(SupportsDraggableRegion());
draggable_region_ = region;
void ChromeBrowserDelegate::DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) {
if (SupportsDraggableRegion()) {
SkRegion sk_region;
for (const auto& region : regions) {
sk_region.op(
SkIRect::MakeLTRB(region->bounds.x(), region->bounds.y(),
region->bounds.x() + region->bounds.width(),
region->bounds.y() + region->bounds.height()),
region->draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
}
draggable_region_ = sk_region;
} else if (auto delegate = GetDelegateForWebContents(contents)) {
delegate->DraggableRegionsChanged(regions, contents);
}
}
void ChromeBrowserDelegate::WindowFullscreenStateChanged() {
@@ -512,9 +528,11 @@ void ChromeBrowserDelegate::WebContentsCreated(
/*is_devtools_popup=*/false, opener);
}
content::WebContents* ChromeBrowserDelegate::OpenURLFromTab(
content::WebContents* ChromeBrowserDelegate::OpenURLFromTabEx(
content::WebContents* source,
const content::OpenURLParams& params) {
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>&
navigation_handle_callback) {
// |source| may be nullptr when opening a link from chrome UI such as the
// Reading List sidebar. In that case we default to using the Browser's
// currently active WebContents.
@@ -526,7 +544,8 @@ content::WebContents* ChromeBrowserDelegate::OpenURLFromTab(
// Return nullptr to cancel the navigation. Otherwise, proceed with default
// chrome handling.
if (auto delegate = GetDelegateForWebContents(source)) {
return delegate->OpenURLFromTab(source, params);
return delegate->OpenURLFromTabEx(source, params,
navigation_handle_callback);
}
return nullptr;
}

12
libcef/browser/chrome/chrome_browser_delegate.h
View File

@@ -87,9 +87,13 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
std::optional<bool> SupportsWindowFeature(int feature) const override;
bool SupportsDraggableRegion() const override;
const std::optional<SkRegion> GetDraggableRegion() const override;
void UpdateDraggableRegion(const SkRegion& region) override;
void WindowFullscreenStateChanged() override;
bool HasViewsHostedOpener() const override;
content::WebContents* OpenURLFromTabEx(
content::WebContents* source,
const content::OpenURLParams& params,
base::OnceCallback<void(content::NavigationHandle&)>&
navigation_handle_callback) override;
// WebContentsDelegate methods:
void WebContentsCreated(content::WebContents* source_contents,
@@ -98,9 +102,6 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
const std::string& frame_name,
const GURL& target_url,
content::WebContents* new_contents) override;
content::WebContents* OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) override;
void LoadingStateChanged(content::WebContents* source,
bool should_show_loading_ui) override;
void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
@@ -122,6 +123,9 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
bool HandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event) override;
void DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) override;
Browser* browser() const { return browser_; }

7
libcef/browser/chrome/chrome_browser_host_impl.cc
View File

@@ -146,7 +146,12 @@ void ChromeBrowserHostImpl::OnWebContentsDestroyed(
// CefBrowserInfoManager::DestroyAllBrowsers().
if (platform_delegate_) {
platform_delegate_->WebContentsDestroyed(web_contents);
DestroyBrowser();
// Destroy the browser asynchronously to allow the current call stack
// to unwind (we may have been called via the TabStripModel owned by the
// Browser).
CEF_POST_TASK(CEF_UIT,
base::BindOnce(&ChromeBrowserHostImpl::DestroyBrowser, this));
}
}

9
libcef/browser/chrome/chrome_content_browser_client_cef.cc
View File

@@ -236,6 +236,7 @@ void ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
const net::IsolationInfo& isolation_info,
std::optional<int64_t> navigation_id,
ukm::SourceIdObj ukm_source_id,
network::URLLoaderFactoryBuilder& factory_builder,
@@ -252,9 +253,9 @@ void ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
if (!CefBrowserContext::FromProfile(profile)) {
ChromeContentBrowserClient::WillCreateURLLoaderFactory(
browser_context, frame, render_process_id, type, request_initiator,
navigation_id, ukm_source_id, factory_builder, header_client,
bypass_redirect_checks, disable_secure_dns, factory_override,
navigation_response_task_runner);
isolation_info, navigation_id, ukm_source_id, factory_builder,
header_client, bypass_redirect_checks, disable_secure_dns,
factory_override, navigation_response_task_runner);
return;
}
@@ -283,7 +284,7 @@ void ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
// TODO(chrome): Is it necessary to proxy |header_client| callbacks?
ChromeContentBrowserClient::WillCreateURLLoaderFactory(
browser_context, frame, render_process_id, type, request_initiator,
navigation_id, ukm_source_id, factory_builder,
isolation_info, navigation_id, ukm_source_id, factory_builder,
/*header_client=*/nullptr, bypass_redirect_checks, disable_secure_dns,
handler_override, navigation_response_task_runner);

1
libcef/browser/chrome/chrome_content_browser_client_cef.h
View File

@@ -62,6 +62,7 @@ class ChromeContentBrowserClientCef : public ChromeContentBrowserClient {
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
const net::IsolationInfo& isolation_info,
std::optional<int64_t> navigation_id,
ukm::SourceIdObj ukm_source_id,
network::URLLoaderFactoryBuilder& factory_builder,

6
libcef/browser/devtools/devtools_controller.cc
View File

@@ -29,7 +29,7 @@ CefDevToolsController::~CefDevToolsController() {
}
bool CefDevToolsController::SendDevToolsMessage(
const base::StringPiece& message) {
const std::string_view& message) {
CEF_REQUIRE_UIT();
if (!EnsureAgentHost()) {
return false;
@@ -100,8 +100,8 @@ void CefDevToolsController::DispatchProtocolMessage(
return;
}
base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),
message.size());
std::string_view str_message(reinterpret_cast<const char*>(message.data()),
message.size());
if (!devtools_util::ProtocolParser::IsValidMessage(str_message)) {
LOG(WARNING) << "Invalid message: " << str_message.substr(0, 100);
return;

13
libcef/browser/devtools/devtools_controller.h
View File

@@ -7,13 +7,12 @@
#include <memory>
#include "content/public/browser/devtools_agent_host_client.h"
#include "base/containers/span.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/values.h"
#include "content/public/browser/devtools_agent_host_client.h"
namespace content {
class WebContents;
@@ -24,12 +23,12 @@ class CefDevToolsController : public content::DevToolsAgentHostClient {
class Observer : public base::CheckedObserver {
public:
// See CefDevToolsMessageObserver documentation.
virtual bool OnDevToolsMessage(const base::StringPiece& message) = 0;
virtual bool OnDevToolsMessage(const std::string_view& message) = 0;
virtual void OnDevToolsMethodResult(int message_id,
bool success,
const base::StringPiece& result) = 0;
virtual void OnDevToolsEvent(const base::StringPiece& method,
const base::StringPiece& params) = 0;
const std::string_view& result) = 0;
virtual void OnDevToolsEvent(const std::string_view& method,
const std::string_view& params) = 0;
virtual void OnDevToolsAgentAttached() = 0;
virtual void OnDevToolsAgentDetached() = 0;
@@ -48,7 +47,7 @@ class CefDevToolsController : public content::DevToolsAgentHostClient {
~CefDevToolsController() override;
// See CefBrowserHost methods of the same name for documentation.
bool SendDevToolsMessage(const base::StringPiece& message);
bool SendDevToolsMessage(const std::string_view& message);
int ExecuteDevToolsMethod(int message_id,
const std::string& method,
const base::Value::Dict* params);

10
libcef/browser/devtools/devtools_protocol_manager.cc
View File

@@ -50,7 +50,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
private:
// CefDevToolsController::Observer methods:
bool OnDevToolsMessage(const base::StringPiece& message) override {
bool OnDevToolsMessage(const std::string_view& message) override {
CEF_REQUIRE_UIT();
return observer_->OnDevToolsMessage(browser_, message.data(),
message.size());
@@ -58,14 +58,14 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
void OnDevToolsMethodResult(int message_id,
bool success,
const base::StringPiece& result) override {
const std::string_view& result) override {
CEF_REQUIRE_UIT();
observer_->OnDevToolsMethodResult(browser_, message_id, success,
result.data(), result.size());
}
void OnDevToolsEvent(const base::StringPiece& method,
const base::StringPiece& params) override {
void OnDevToolsEvent(const std::string_view& method,
const std::string_view& params) override {
CEF_REQUIRE_UIT();
observer_->OnDevToolsEvent(browser_, std::string(method), params.data(),
params.size());
@@ -119,7 +119,7 @@ bool CefDevToolsProtocolManager::SendDevToolsMessage(const void* message,
}
return devtools_controller_->SendDevToolsMessage(
base::StringPiece(static_cast<const char*>(message), message_size));
std::string_view(static_cast<const char*>(message), message_size));
}
int CefDevToolsProtocolManager::ExecuteDevToolsMethod(

28
libcef/browser/devtools/devtools_util.cc
View File

@@ -11,16 +11,16 @@ namespace devtools_util {
namespace {
bool IsValidDictionary(const base::StringPiece& str, bool allow_empty) {
bool IsValidDictionary(const std::string_view& str, bool allow_empty) {
return str.length() >= (allow_empty ? 2 : 3) && str[0] == '{' &&
str[str.length() - 1] == '}';
}
// Example:
// {"method":"Target.targetDestroyed","params":{"targetId":"1234..."}}
bool ParseEvent(const base::StringPiece& message,
base::StringPiece& method,
base::StringPiece& params) {
bool ParseEvent(const std::string_view& message,
std::string_view& method,
std::string_view& params) {
static const char kMethodStart[] = "{\"method\":\"";
static const char kMethodEnd[] = "\"";
static const char kParamsStart[] = ",\"params\":";
@@ -31,7 +31,7 @@ bool ParseEvent(const base::StringPiece& message,
const size_t method_start = sizeof(kMethodStart) - 1;
const size_t method_end = message.find(kMethodEnd, method_start);
if (method_end == base::StringPiece::npos) {
if (method_end == std::string_view::npos) {
return false;
}
method = message.substr(method_start, method_end - method_start);
@@ -42,9 +42,9 @@ bool ParseEvent(const base::StringPiece& message,
size_t remainder_start = method_end + sizeof(kMethodEnd) - 1;
if (remainder_start == message.size() - 1) {
// No more contents.
params = base::StringPiece();
params = std::string_view();
} else {
const base::StringPiece& remainder = message.substr(remainder_start);
const std::string_view& remainder = message.substr(remainder_start);
if (base::StartsWith(remainder, kParamsStart)) {
// Stop immediately before the message closing bracket.
remainder_start += sizeof(kParamsStart) - 1;
@@ -67,10 +67,10 @@ bool ParseEvent(const base::StringPiece& message,
// {"id":3,"result":{}}
// {"id":4,"result":{"debuggerId":"-2193881606781505058.81393575456727957"}}
// {"id":5,"error":{"code":-32000,"message":"Not supported"}}
bool ParseResult(const base::StringPiece& message,
bool ParseResult(const std::string_view& message,
int& message_id,
bool& success,
base::StringPiece& result) {
std::string_view& result) {
static const char kIdStart[] = "{\"id\":";
static const char kIdEnd[] = ",";
static const char kResultStart[] = "\"result\":";
@@ -82,16 +82,16 @@ bool ParseResult(const base::StringPiece& message,
const size_t id_start = sizeof(kIdStart) - 1;
const size_t id_end = message.find(kIdEnd, id_start);
if (id_end == base::StringPiece::npos) {
if (id_end == std::string_view::npos) {
return false;
}
const base::StringPiece& id_str = message.substr(id_start, id_end - id_start);
const std::string_view& id_str = message.substr(id_start, id_end - id_start);
if (id_str.empty() || !base::StringToInt(id_str, &message_id)) {
return false;
}
size_t remainder_start = id_end + sizeof(kIdEnd) - 1;
const base::StringPiece& remainder = message.substr(remainder_start);
const std::string_view& remainder = message.substr(remainder_start);
if (base::StartsWith(remainder, kResultStart)) {
// Stop immediately before the message closing bracket.
remainder_start += sizeof(kResultStart) - 1;
@@ -119,11 +119,11 @@ bool ParseResult(const base::StringPiece& message,
} // namespace
// static
bool ProtocolParser::IsValidMessage(const base::StringPiece& message) {
bool ProtocolParser::IsValidMessage(const std::string_view& message) {
return IsValidDictionary(message, /*allow_empty=*/false);
}
bool ProtocolParser::Initialize(const base::StringPiece& message) {
bool ProtocolParser::Initialize(const std::string_view& message) {
if (status_ != UNINITIALIZED) {
return false;
}

12
libcef/browser/devtools/devtools_util.h
View File

@@ -6,7 +6,7 @@
#define CEF_LIBCEF_BROWSER_DEVTOOLS_DEVTOOLS_UTIL_H_
#pragma once
#include "base/strings/string_piece.h"
#include <string_view>
namespace devtools_util {
@@ -31,10 +31,10 @@ struct ProtocolParser {
ProtocolParser() = default;
// Checks for a non-empty JSON dictionary.
static bool IsValidMessage(const base::StringPiece& message);
static bool IsValidMessage(const std::string_view& message);
// Returns false if already initialized.
bool Initialize(const base::StringPiece& message);
bool Initialize(const std::string_view& message);
bool IsInitialized() const { return status_ != UNINITIALIZED; }
bool IsEvent() const { return status_ == EVENT; }
@@ -45,7 +45,7 @@ struct ProtocolParser {
// For event messages:
// "method" string:
base::StringPiece method_;
std::string_view method_;
// For result messages:
// "id" int:
@@ -55,7 +55,7 @@ struct ProtocolParser {
// For both:
// "params", "result" or "error" dictionary:
base::StringPiece params_;
std::string_view params_;
private:
enum Status {
@@ -69,4 +69,4 @@ struct ProtocolParser {
} // namespace devtools_util
#endif // CEF_LIBCEF_BROWSER_DEVTOOLS_DEVTOOLS_UTIL_H_
#endif // CEF_LIBCEF_BROWSER_DEVTOOLS_DEVTOOLS_UTIL_H_

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

@@ -59,7 +59,7 @@ namespace {
// Implementation based on ComponentLoader::ParseManifest.
std::optional<base::Value::Dict> ParseManifest(
base::StringPiece manifest_contents) {
std::string_view manifest_contents) {
JSONStringValueDeserializer deserializer(manifest_contents);
std::unique_ptr<base::Value> manifest =
deserializer.Deserialize(nullptr, nullptr);

3
libcef/browser/media_stream_registrar.cc
View File

@@ -39,7 +39,8 @@ class CefMediaStreamUI : public content::MediaStreamUI {
void OnDeviceStoppedForSourceChange(
const std::string& label,
const content::DesktopMediaID& old_media_id,
const content::DesktopMediaID& new_media_id) override {}
const content::DesktopMediaID& new_media_id,
bool captured_surface_control_active) override {}
void OnDeviceStopped(const std::string& label,
const content::DesktopMediaID& media_id) override {}

2
libcef/browser/net_service/browser_urlrequest_impl.cc
View File

@@ -500,7 +500,7 @@ class CefBrowserURLRequest::Context
}
// SimpleURLLoaderStreamConsumer methods:
void OnDataReceived(base::StringPiece string_piece,
void OnDataReceived(std::string_view string_piece,
base::OnceClosure resume) override {
DCHECK(CalledOnValidThread());
DCHECK_EQ(status_, UR_IO_PENDING);

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

@@ -253,7 +253,8 @@ void LoadCookies(const CefBrowserContext::Getter& browser_context_getter,
!request.trusted_params->isolation_info.IsEmpty()) {
partition_key_collection = net::CookiePartitionKeyCollection::FromOptional(
net::CookiePartitionKey::FromNetworkIsolationKey(
request.trusted_params->isolation_info.network_isolation_key()));
request.trusted_params->isolation_info.network_isolation_key(),
request.site_for_cookies, net::SchemefulSite(request.url)));
}
CEF_POST_TASK(
@@ -286,7 +287,7 @@ void SaveCookies(const CefBrowserContext::Getter& browser_context_getter,
response_date = base::Time();
}
const base::StringPiece name(net_service::kHTTPSetCookieHeaderName);
const std::string_view name(net_service::kHTTPSetCookieHeaderName);
std::string cookie_string;
size_t iter = 0;
net::CookieList allowed_cookies;
@@ -300,7 +301,8 @@ void SaveCookies(const CefBrowserContext::Getter& browser_context_getter,
request.url, cookie_string, base::Time::Now(),
std::make_optional(response_date),
/*cookie_partition_key=*/std::nullopt,
/*block_truncated=*/true, &returned_status);
/*block_truncated=*/true, net::CookieSourceType::kHTTP,
&returned_status);
if (!returned_status.IsInclude()) {
continue;
}

2
libcef/browser/net_service/cookie_manager_impl.cc
View File

@@ -303,7 +303,7 @@ bool CefCookieManagerImpl::SetCookieInternal(
/*creation_time=*/base::Time(), expiration_time,
/*last_access_time=*/base::Time(), cookie.secure ? true : false,
cookie.httponly ? true : false, same_site, priority,
/*partition_key=*/std::nullopt);
/*partition_key=*/std::nullopt, /*status=*/nullptr);
if (!canonical_cookie) {
SetCookieCallbackImpl(

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

@@ -6,14 +6,14 @@
#ifndef CEF_LIBCEF_BROWSER_NET_SERVICE_PROXY_URL_LOADER_FACTORY_H_
#define CEF_LIBCEF_BROWSER_NET_SERVICE_PROXY_URL_LOADER_FACTORY_H_
#include "libcef/browser/net_service/stream_reader_url_loader.h"
#include <optional>
#include <string_view>
#include "libcef/browser/net_service/stream_reader_url_loader.h"
#include "base/containers/unique_ptr_adapters.h"
#include "base/functional/callback.h"
#include "base/hash/hash.h"
#include "base/strings/string_piece.h"
#include "content/public/browser/content_browser_client.h"
#include "content/public/browser/web_contents.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"

2
libcef/browser/net_service/response_filter_wrapper.cc
View File

@@ -215,7 +215,7 @@ void ResponseFilterWrapper::Write(std::unique_ptr<std::string> data) {
write_pending_ = true;
base::StringPiece string_piece(*data);
std::string_view string_piece(*data);
forwarder_->Write(std::make_unique<mojo::StringDataSource>(
string_piece, mojo::StringDataSource::AsyncWritingMode::
STRING_STAYS_VALID_UNTIL_COMPLETION),

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

@@ -45,8 +45,8 @@ scoped_refptr<URLLoaderFactoryGetter> URLLoaderFactoryGetter::Create(
// Allow DevTools to potentially inject itself into the proxy pipe.
content::devtools_instrumentation::WillCreateURLLoaderFactoryParams::
ForFrame(static_cast<content::RenderFrameHostImpl*>(render_frame_host))
.Run(false /* is_navigation */, false /* is_download */,
factory_builder, nullptr /* factory_override */);
.Run(/*is_navigation=*/false, /*is_download=*/false,
factory_builder, /*factory_override=*/nullptr);
}
auto browser_client = CefAppManager::Get()->GetContentClient()->browser();
@@ -55,11 +55,11 @@ scoped_refptr<URLLoaderFactoryGetter> URLLoaderFactoryGetter::Create(
browser_client->WillCreateURLLoaderFactory(
browser_context, render_frame_host, render_process_id,
content::ContentBrowserClient::URLLoaderFactoryType::kDocumentSubResource,
url::Origin(), std::nullopt /* navigation_id */, ukm::SourceIdObj(),
factory_builder, nullptr /* header_client */,
nullptr /* bypass_redirect_checks */, nullptr /* disable_secure_dns */,
nullptr /* factory_override */,
nullptr /* navigation_response_task_runner */);
url::Origin(), net::IsolationInfo(), /*navigation_id=*/std::nullopt,
ukm::SourceIdObj(), factory_builder, /*header_client=*/nullptr,
/*bypass_redirect_checks=*/nullptr, /*disable_secure_dns=*/nullptr,
/*factory_override=*/nullptr,
/*navigation_response_task_runner=*/nullptr);
return base::WrapRefCounted(new URLLoaderFactoryGetter(
loader_factory->Clone(), std::move(factory_builder)));

32
libcef/browser/osr/browser_platform_delegate_osr.cc
View File

@@ -328,17 +328,21 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragEnter(
gfx::PointF transformed_pt;
// Some random crashes occured when GetWeakPtr is called on a null pointer
// that is the return of GetRenderWidgetHostAtPoint As the root cause is not
// yet understood (no reproducible scenario yet), the current fix is only a
// protection against null pointer dereferencing.
content::RenderWidgetHostImpl* ptr_current_rwh_for_drag =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
// that is the return of GetRenderWidgetHostViewInputAtPoint. As the root
// cause is not yet understood (no reproducible scenario yet), the current fix
// is only a protection against null pointer dereferencing.
auto* view =
web_contents->GetInputEventRouter()->GetRenderWidgetHostViewInputAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
gfx::PointF(client_pt), &transformed_pt);
if (!ptr_current_rwh_for_drag) {
if (!view) {
return;
}
current_rwh_for_drag_ = ptr_current_rwh_for_drag->GetWeakPtr();
auto* target_rwh = content::RenderWidgetHostImpl::From(
static_cast<content::RenderWidgetHostViewBase*>(view)
->GetRenderWidgetHost());
current_rwh_for_drag_ = target_rwh->GetWeakPtr();
current_rvh_for_drag_ = web_contents->GetRenderViewHost();
@@ -387,10 +391,13 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragOver(
GetScreenPoint(client_pt, /*want_dip_coords=*/false);
gfx::PointF transformed_pt;
content::RenderWidgetHostImpl* target_rwh =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
auto* view =
web_contents->GetInputEventRouter()->GetRenderWidgetHostViewInputAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
gfx::PointF(client_pt), &transformed_pt);
auto* target_rwh = content::RenderWidgetHostImpl::From(
static_cast<content::RenderWidgetHostViewBase*>(view)
->GetRenderWidgetHost());
if (target_rwh != current_rwh_for_drag_.get()) {
if (current_rwh_for_drag_) {
@@ -458,10 +465,13 @@ void CefBrowserPlatformDelegateOsr::DragTargetDrop(const CefMouseEvent& event) {
GetScreenPoint(client_pt, /*want_dip_coords=*/false);
gfx::PointF transformed_pt;
content::RenderWidgetHostImpl* target_rwh =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
auto* view =
web_contents->GetInputEventRouter()->GetRenderWidgetHostViewInputAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
gfx::PointF(client_pt), &transformed_pt);
auto* target_rwh = content::RenderWidgetHostImpl::From(
static_cast<content::RenderWidgetHostViewBase*>(view)
->GetRenderWidgetHost());
if (target_rwh != current_rwh_for_drag_.get()) {
if (current_rwh_for_drag_) {

4
libcef/browser/permission_prompt.cc
View File

@@ -129,6 +129,10 @@ class CefPermissionPrompt : public permissions::PermissionPrompt {
return std::nullopt;
}
bool ShouldFinalizeRequestAfterDecided() const override { return true; }
std::vector<permissions::ElementAnchoredBubbleVariant> GetPromptVariants()
const override {
return {};
}
private:
// We don't expose AcceptThisTime() because it's a special case for

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

@@ -27,7 +27,9 @@
#include "chrome/browser/preloading/preloading_prefs.h"
#include "chrome/browser/printing/print_preview_sticky_settings.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_key.h"
#include "chrome/browser/ssl/ssl_config_service_manager.h"
#include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
#include "chrome/browser/themes/theme_service.h"
#include "chrome/browser/ui/browser_view_prefs.h"
#include "chrome/browser/ui/webui/accessibility/accessibility_ui.h"
@@ -61,7 +63,8 @@
#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
#include "components/safe_search_api/safe_search_util.h"
#include "components/spellcheck/browser/pref_names.h"
#include "components/supervised_user/core/common/buildflags.h"
#include "components/supervised_user/core/browser/supervised_user_pref_store.h"
#include "components/supervised_user/core/browser/supervised_user_settings_service.h"
#include "components/sync_preferences/pref_service_syncable.h"
#include "components/sync_preferences/pref_service_syncable_factory.h"
#include "components/unified_consent/unified_consent_service.h"
@@ -77,13 +80,6 @@
#include "components/os_crypt/sync/os_crypt.h"
#endif
#if BUILDFLAG(ENABLE_SUPERVISED_USERS)
#include "chrome/browser/profiles/profile_key.h"
#include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
#include "components/supervised_user/core/browser/supervised_user_pref_store.h"
#include "components/supervised_user/core/browser/supervised_user_settings_service.h"
#endif
namespace browser_prefs {
namespace {
@@ -170,7 +166,6 @@ std::unique_ptr<PrefService> CreatePrefService(Profile* profile,
factory.set_user_prefs(cef_pref_store.get());
}
#if BUILDFLAG(ENABLE_SUPERVISED_USERS)
if (profile) {
// Used to store supervised user preferences.
auto* supervised_user_settings =
@@ -191,7 +186,6 @@ std::unique_ptr<PrefService> CreatePrefService(Profile* profile,
DCHECK(supervised_user_prefs->IsInitializationComplete());
factory.set_supervised_user_prefs(supervised_user_prefs);
}
#endif // BUILDFLAG(ENABLE_SUPERVISED_USERS)
// Registry that will be populated with all known preferences. Preferences
// are registered with default values that may be changed via a *PrefStore.

2
libcef/browser/prefs/pref_store.cc
View File

@@ -12,7 +12,7 @@
CefPrefStore::CefPrefStore() = default;
bool CefPrefStore::GetValue(base::StringPiece key,
bool CefPrefStore::GetValue(std::string_view key,
const base::Value** value) const {
return prefs_.GetValue(key, value);
}

2
libcef/browser/prefs/pref_store.h
View File

@@ -24,7 +24,7 @@ class CefPrefStore : public PersistentPrefStore {
CefPrefStore& operator=(const CefPrefStore&) = delete;
// Overriden from PrefStore.
bool GetValue(base::StringPiece key,
bool GetValue(std::string_view key,
const base::Value** result) const override;
base::Value::Dict GetValues() const override;
void AddObserver(PrefStore::Observer* observer) override;

4
libcef/browser/speech_recognition_manager_delegate.cc
View File

@@ -89,3 +89,7 @@ bool CefSpeechRecognitionManagerDelegate::FilterProfanities(
int render_process_id) {
return filter_profanities_;
}
void CefSpeechRecognitionManagerDelegate::BindSpeechRecognitionContext(
mojo::PendingReceiver<media::mojom::SpeechRecognitionContext>
recognition_receiver) {}

3
libcef/browser/speech_recognition_manager_delegate.h
View File

@@ -52,6 +52,9 @@ class CefSpeechRecognitionManagerDelegate
override;
content::SpeechRecognitionEventListener* GetEventListener() override;
bool FilterProfanities(int render_process_id) override;
void BindSpeechRecognitionContext(
mojo::PendingReceiver<media::mojom::SpeechRecognitionContext> receiver)
override;
private:
bool filter_profanities_;

12
libcef/browser/test/test_server_impl.cc
View File

@@ -33,9 +33,9 @@ class CefTestServerConnectionImpl : public CefTestServerConnection {
size_t data_size) override {
auto response = std::make_unique<BasicHttpResponse>();
response->set_code(net::HTTP_OK);
response->set_content_type(base::StringPiece(content_type.ToString()));
response->set_content_type(std::string_view(content_type.ToString()));
response->set_content(
base::StringPiece(reinterpret_cast<const char*>(data), data_size));
std::string_view(reinterpret_cast<const char*>(data), data_size));
SendBasicHttpResponse(std::move(response));
}
@@ -48,8 +48,8 @@ class CefTestServerConnectionImpl : public CefTestServerConnection {
void SendHttp500Response(const CefString& error_message) override {
auto response = std::make_unique<BasicHttpResponse>();
response->set_code(net::HTTP_INTERNAL_SERVER_ERROR);
response->set_content_type(base::StringPiece("text/html"));
response->set_content(base::StringPiece(error_message.ToString()));
response->set_content_type(std::string_view("text/html"));
response->set_content(std::string_view(error_message.ToString()));
SendBasicHttpResponse(std::move(response));
}
@@ -60,9 +60,9 @@ class CefTestServerConnectionImpl : public CefTestServerConnection {
const HeaderMap& extra_headers) override {
auto response = std::make_unique<BasicHttpResponse>();
response->set_code(static_cast<net::HttpStatusCode>(response_code));
response->set_content_type(base::StringPiece(content_type.ToString()));
response->set_content_type(std::string_view(content_type.ToString()));
response->set_content(
base::StringPiece(reinterpret_cast<const char*>(data), data_size));
std::string_view(reinterpret_cast<const char*>(data), data_size));
for (const auto& [key, value] : extra_headers) {
response->AddCustomHeader(key.ToString(), value.ToString());
}

3
libcef/browser/views/view_impl.h
View File

@@ -299,6 +299,7 @@
#include "base/logging.h"
#include "base/values.h"
#include "ui/gfx/color_palette.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/view.h"
@@ -667,7 +668,7 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::IsFocusable() {
CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::IsAccessibilityFocusable() {
CEF_REQUIRE_VALID_RETURN(false);
return root_view()->IsAccessibilityFocusable();
return root_view()->GetViewAccessibility().IsAccessibilityFocusable();
}
CEF_VIEW_IMPL_T void CEF_VIEW_IMPL_D::RequestFocus() {