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 81.0.4044.0 (#737173)

Browse Source
This commit is contained in:
Marshall Greenblatt
2020-03-03 19:29:39 -05:00
parent a22b670a00
commit 9d9ee8b45f
135 changed files with 2602 additions and 1329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
libcef/browser/browser_host_impl.cc
View File

@ -1708,9 +1708,9 @@ void CefBrowserHostImpl::OnSetFocus(cef_focus_source_t source) {
void CefBrowserHostImpl::RunFileChooser(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback) {
CefFileDialogRunner::RunFileChooserCallback callback) {
EnsureFileDialogManager();
file_dialog_manager_->RunFileChooser(params, callback);
file_dialog_manager_->RunFileChooser(params, std::move(callback));
}
bool CefBrowserHostImpl::EmbedsFullscreenWidget() {
@ -2467,9 +2467,9 @@ bool CefBrowserHostImpl::CheckMediaAccessPermission(
return command_line->HasSwitch(switches::kEnableMediaStream);
}
bool CefBrowserHostImpl::IsNeverVisible(content::WebContents* web_contents) {
bool CefBrowserHostImpl::IsNeverComposited(content::WebContents* web_contents) {
if (extension_host_)
return extension_host_->IsNeverVisible(web_contents);
return extension_host_->IsNeverComposited(web_contents);
return false;
}
@ -2651,8 +2651,7 @@ void CefBrowserHostImpl::DocumentAvailableInMainFrame() {
void CefBrowserHostImpl::DidFailLoad(
content::RenderFrameHost* render_frame_host,
const GURL& validated_url,
int error_code,
const base::string16& error_description) {
int error_code) {
// The navigation failed after commit. OnLoadStart was called so we also call
// OnLoadEnd.
auto frame = browser_info_->GetFrameForHost(render_frame_host);

10
libcef/browser/browser_host_impl.h
View File

@ -351,9 +351,8 @@ class CefBrowserHostImpl : public CefBrowserHost,
// Run the file chooser dialog specified by |params|. Only a single dialog may
// be pending at any given time. |callback| will be executed asynchronously
// after the dialog is dismissed or if another dialog is already pending.
void RunFileChooser(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback);
void RunFileChooser(const CefFileDialogRunner::FileChooserParams& params,
CefFileDialogRunner::RunFileChooserCallback callback);
bool HandleContextMenu(content::WebContents* web_contents,
const content::ContextMenuParams& params);
@ -458,7 +457,7 @@ class CefBrowserHostImpl : public CefBrowserHost,
bool CheckMediaAccessPermission(content::RenderFrameHost* render_frame_host,
const GURL& security_origin,
blink::mojom::MediaStreamType type) override;
bool IsNeverVisible(content::WebContents* web_contents) override;
bool IsNeverComposited(content::WebContents* web_contents) override;
content::PictureInPictureResult EnterPictureInPicture(
content::WebContents* web_contents,
const viz::SurfaceId& surface_id,
@ -481,8 +480,7 @@ class CefBrowserHostImpl : public CefBrowserHost,
void DocumentAvailableInMainFrame() override;
void DidFailLoad(content::RenderFrameHost* render_frame_host,
const GURL& validated_url,
int error_code,
const base::string16& error_description) override;
int error_code) override;
void TitleWasSet(content::NavigationEntry* entry) override;
void PluginCrashed(const base::FilePath& plugin_path,
base::ProcessId plugin_pid) override;

11
libcef/browser/browser_main.cc
View File

@ -50,6 +50,7 @@
#include "ui/wm/core/wm_state.h"
#if defined(OS_WIN)
#include "components/os_crypt/os_crypt.h"
#include "ui/base/cursor/cursor_loader_win.h"
#endif
#endif // defined(USE_AURA)
@ -71,11 +72,6 @@
#include "libcef/browser/printing/print_dialog_linux.h"
#endif
#if defined(OS_MACOSX) || defined(OS_WIN)
#include "chrome/browser/browser_process.h"
#include "components/os_crypt/os_crypt.h"
#endif
CefBrowserMainParts::CefBrowserMainParts(
const content::MainFunctionParams& parameters)
: BrowserMainParts(), devtools_delegate_(nullptr) {}
@ -122,11 +118,12 @@ void CefBrowserMainParts::PreMainMessageLoopStart() {
ui::TouchFactory::SetTouchDeviceListFromCommandLine();
#endif
#if defined(OS_MACOSX) || defined(OS_WIN)
#if defined(OS_WIN)
// Initialize the OSCrypt.
PrefService* local_state = g_browser_process->local_state();
DCHECK(local_state);
OSCrypt::Init(local_state);
bool os_crypt_init = OSCrypt::Init(local_state);
DCHECK(os_crypt_init);
#endif
}

84
libcef/browser/content_browser_client.cc
View File

@ -136,7 +136,6 @@
#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
@ -157,18 +156,19 @@ namespace {
class CefQuotaCallbackImpl : public CefRequestCallback {
public:
explicit CefQuotaCallbackImpl(
const content::QuotaPermissionContext::PermissionCallback& callback)
: callback_(callback) {}
using CallbackType = content::QuotaPermissionContext::PermissionCallback;
explicit CefQuotaCallbackImpl(CallbackType callback)
: callback_(std::move(callback)) {}
~CefQuotaCallbackImpl() {
if (!callback_.is_null()) {
// The callback is still pending. Cancel it now.
if (CEF_CURRENTLY_ON_IOT()) {
RunNow(callback_, false);
RunNow(std::move(callback_), false);
} else {
CEF_POST_TASK(CEF_IOT, base::Bind(&CefQuotaCallbackImpl::RunNow,
callback_, false));
CEF_POST_TASK(CEF_IOT, base::BindOnce(&CefQuotaCallbackImpl::RunNow,
std::move(callback_), false));
}
}
}
@ -176,31 +176,28 @@ class CefQuotaCallbackImpl : public CefRequestCallback {
void Continue(bool allow) override {
if (CEF_CURRENTLY_ON_IOT()) {
if (!callback_.is_null()) {
RunNow(callback_, allow);
callback_.Reset();
RunNow(std::move(callback_), allow);
}
} else {
CEF_POST_TASK(CEF_IOT,
base::Bind(&CefQuotaCallbackImpl::Continue, this, allow));
CEF_POST_TASK(CEF_IOT, base::BindOnce(&CefQuotaCallbackImpl::Continue,
this, allow));
}
}
void Cancel() override { Continue(false); }
void Disconnect() { callback_.Reset(); }
CallbackType Disconnect() WARN_UNUSED_RESULT { return std::move(callback_); }
private:
static void RunNow(
const content::QuotaPermissionContext::PermissionCallback& callback,
bool allow) {
static void RunNow(CallbackType callback, bool allow) {
CEF_REQUIRE_IOT();
callback.Run(
std::move(callback).Run(
allow ? content::QuotaPermissionContext::QUOTA_PERMISSION_RESPONSE_ALLOW
: content::QuotaPermissionContext::
QUOTA_PERMISSION_RESPONSE_DISALLOW);
}
content::QuotaPermissionContext::PermissionCallback callback_;
CallbackType callback_;
IMPLEMENT_REFCOUNTING(CefQuotaCallbackImpl);
DISALLOW_COPY_AND_ASSIGN(CefQuotaCallbackImpl);
@ -282,9 +279,10 @@ class CefSelectClientCertificateCallbackImpl
if (CEF_CURRENTLY_ON_UIT()) {
RunNow(std::move(delegate_), cert);
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefSelectClientCertificateCallbackImpl::RunNow,
base::Passed(std::move(delegate_)), cert));
CEF_POST_TASK(
CEF_UIT,
base::BindOnce(&CefSelectClientCertificateCallbackImpl::RunNow,
std::move(delegate_), cert));
}
}
@ -296,9 +294,9 @@ class CefSelectClientCertificateCallbackImpl
if (cert) {
CefX509CertificateImpl* certImpl =
static_cast<CefX509CertificateImpl*>(cert.get());
certImpl->AcquirePrivateKey(
base::Bind(&CefSelectClientCertificateCallbackImpl::RunWithPrivateKey,
base::Passed(std::move(delegate)), cert));
certImpl->AcquirePrivateKey(base::BindOnce(
&CefSelectClientCertificateCallbackImpl::RunWithPrivateKey,
std::move(delegate), cert));
return;
}
@ -334,11 +332,11 @@ class CefQuotaPermissionContext : public content::QuotaPermissionContext {
// The callback will be dispatched on the IO thread.
void RequestQuotaPermission(const content::StorageQuotaParams& params,
int render_process_id,
const PermissionCallback& callback) override {
PermissionCallback callback) override {
if (params.storage_type != blink::mojom::StorageType::kPersistent) {
// To match Chrome behavior we only support requesting quota with this
// interface for Persistent storage type.
callback.Run(QUOTA_PERMISSION_RESPONSE_DISALLOW);
std::move(callback).Run(QUOTA_PERMISSION_RESPONSE_DISALLOW);
return;
}
@ -353,19 +351,22 @@ class CefQuotaPermissionContext : public content::QuotaPermissionContext {
CefRefPtr<CefRequestHandler> handler = client->GetRequestHandler();
if (handler.get()) {
CefRefPtr<CefQuotaCallbackImpl> callbackImpl(
new CefQuotaCallbackImpl(callback));
new CefQuotaCallbackImpl(std::move(callback)));
handled = handler->OnQuotaRequest(
browser.get(), params.origin_url.spec(), params.requested_size,
callbackImpl.get());
if (!handled)
callbackImpl->Disconnect();
if (!handled) {
// May return nullptr if the client has already executed the
// callback.
callback = callbackImpl->Disconnect();
}
}
}
}
if (!handled) {
if (!handled && !callback.is_null()) {
// Disallow the request by default.
callback.Run(QUOTA_PERMISSION_RESPONSE_DISALLOW);
std::move(callback).Run(QUOTA_PERMISSION_RESPONSE_DISALLOW);
}
}
@ -843,18 +844,6 @@ void CefContentBrowserClient::AppendExtraCommandLineSwitches(
}
}
void CefContentBrowserClient::AdjustUtilityServiceProcessCommandLine(
const service_manager::Identity& identity,
base::CommandLine* command_line) {
#if defined(OS_MACOSX)
// On Mac, the video-capture and audio services require a CFRunLoop, provided
// by a UI message loop, to run AVFoundation and CoreAudio code.
// See https://crbug.com/834581
if (identity.name() == audio::mojom::kServiceName)
command_line->AppendSwitch(switches::kMessageLoopTypeUi);
#endif
}
std::string CefContentBrowserClient::GetApplicationLocale() {
return g_browser_process->GetApplicationLocale();
}
@ -884,16 +873,6 @@ CefContentBrowserClient::CreateQuotaPermissionContext() {
return new CefQuotaPermissionContext();
}
void CefContentBrowserClient::GetQuotaSettings(
content::BrowserContext* context,
content::StoragePartition* partition,
base::OnceCallback<void(base::Optional<storage::QuotaSettings>)> callback) {
const base::FilePath& cache_path = partition->GetPath();
storage::GetNominalDynamicSettings(
cache_path, cache_path.empty() /* is_incognito */,
storage::GetDefaultDeviceInfoHelper(), std::move(callback));
}
content::MediaObserver* CefContentBrowserClient::GetMediaObserver() {
return CefMediaCaptureDevicesDispatcher::GetInstance();
}
@ -1274,6 +1253,7 @@ bool CefContentBrowserClient::WillCreateURLLoaderFactory(
mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
header_client,
bool* bypass_redirect_checks,
bool* disable_secure_dns,
network::mojom::URLLoaderFactoryOverridePtr* factory_override) {
auto request_handler = net_service::CreateInterceptedRequestHandler(
browser_context, frame, render_process_id,

9
libcef/browser/content_browser_client.h
View File

@ -63,20 +63,12 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
base::StringPiece name) override;
void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) override;
void AdjustUtilityServiceProcessCommandLine(
const service_manager::Identity& identity,
base::CommandLine* command_line) override;
std::string GetApplicationLocale() override;
scoped_refptr<network::SharedURLLoaderFactory>
GetSystemSharedURLLoaderFactory() override;
network::mojom::NetworkContext* GetSystemNetworkContext() override;
scoped_refptr<content::QuotaPermissionContext> CreateQuotaPermissionContext()
override;
void GetQuotaSettings(
content::BrowserContext* context,
content::StoragePartition* partition,
base::OnceCallback<void(base::Optional<storage::QuotaSettings>)> callback)
override;
content::MediaObserver* GetMediaObserver() override;
content::SpeechRecognitionManagerDelegate*
CreateSpeechRecognitionManagerDelegate() override;
@ -172,6 +164,7 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
header_client,
bool* bypass_redirect_checks,
bool* disable_secure_dns,
network::mojom::URLLoaderFactoryOverridePtr* factory_override) override;
void OnNetworkServiceCreated(
network::mojom::NetworkService* network_service) override;

40
libcef/browser/devtools/devtools_frontend.cc
View File

@ -45,7 +45,6 @@
#include "net/base/net_errors.h"
#include "net/http/http_response_headers.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "services/network/public/cpp/resource_response.h"
#include "services/network/public/cpp/simple_url_loader.h"
#include "services/network/public/cpp/simple_url_loader_stream_consumer.h"
#include "services/network/public/mojom/url_response_head.mojom.h"
@ -59,9 +58,20 @@ static std::string GetFrontendURL() {
}
std::unique_ptr<base::DictionaryValue> BuildObjectForResponse(
const net::HttpResponseHeaders* rh) {
const net::HttpResponseHeaders* rh,
bool success,
int net_error) {
auto response = std::make_unique<base::DictionaryValue>();
response->SetInteger("statusCode", rh ? rh->response_code() : 200);
int responseCode = 200;
if (rh) {
responseCode = rh->response_code();
} else if (!success) {
// In case of no headers, assume file:// URL and failed to load
responseCode = 404;
}
response->SetInteger("statusCode", responseCode);
response->SetInteger("netError", net_error);
response->SetString("netErrorName", net::ErrorToString(net_error));
auto headers = std::make_unique<base::DictionaryValue>();
size_t iterator = 0;
@ -122,7 +132,8 @@ class CefDevToolsFrontend::NetworkResourceLoader
}
void OnComplete(bool success) override {
auto response = BuildObjectForResponse(response_headers_.get());
auto response = BuildObjectForResponse(response_headers_.get(), success,
loader_->NetError());
bindings_->SendMessageAck(request_id_, response.get());
bindings_->loaders_.erase(bindings_->loaders_.find(this));
@ -289,7 +300,8 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
std::string protocol_message;
if (!agent_host_ || !params->GetString(0, &protocol_message))
return;
agent_host_->DispatchProtocolMessage(this, protocol_message);
agent_host_->DispatchProtocolMessage(
this, base::as_bytes(base::make_span(protocol_message)));
} else if (method == "loadCompleted") {
web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
base::ASCIIToUTF16("DevToolsAPI.setUseSoftMenu(true);"),
@ -308,6 +320,7 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
if (!gurl.is_valid()) {
base::DictionaryValue response;
response.SetInteger("statusCode", 404);
response.SetBoolean("urlValid", false);
SendMessageAck(request_id, &response);
return;
}
@ -344,7 +357,7 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
// TODO(caseq): this preserves behavior of URLFetcher-based
// implementation. We really need to pass proper first party origin from
// the front-end.
resource_request->site_for_cookies = gurl;
resource_request->site_for_cookies = net::SiteForCookies::FromUrl(gurl);
resource_request->headers.AddHeadersFromString(headers);
std::unique_ptr<network::mojom::URLLoaderFactory> file_url_loader_factory;
@ -435,10 +448,12 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
void CefDevToolsFrontend::DispatchProtocolMessage(
content::DevToolsAgentHost* agent_host,
const std::string& message) {
if (message.length() < kMaxMessageChunkSize) {
base::span<const uint8_t> message) {
base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),
message.size());
if (str_message.length() < kMaxMessageChunkSize) {
std::string param;
base::EscapeJSONString(message, true, &param);
base::EscapeJSONString(str_message, true, &param);
std::string code = "DevToolsAPI.dispatchMessage(" + param + ");";
base::string16 javascript = base::UTF8ToUTF16(code);
web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
@ -446,10 +461,11 @@ void CefDevToolsFrontend::DispatchProtocolMessage(
return;
}
size_t total_size = message.length();
for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
size_t total_size = str_message.length();
for (size_t pos = 0; pos < str_message.length();
pos += kMaxMessageChunkSize) {
std::string param;
base::EscapeJSONString(message.substr(pos, kMaxMessageChunkSize), true,
base::EscapeJSONString(str_message.substr(pos, kMaxMessageChunkSize), true,
&param);
std::string code = "DevToolsAPI.dispatchMessageChunk(" + param + "," +
std::to_string(pos ? 0 : total_size) + ");";

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

@ -66,7 +66,7 @@ class CefDevToolsFrontend : public content::WebContentsObserver,
// content::DevToolsAgentHostClient implementation.
void AgentHostClosed(content::DevToolsAgentHost* agent_host) override;
void DispatchProtocolMessage(content::DevToolsAgentHost* agent_host,
const std::string& message) override;
base::span<const uint8_t> message) override;
void HandleMessageFromDevToolsFrontend(const std::string& message);
private:

81
libcef/browser/download_manager_delegate.cc
View File

@ -43,11 +43,11 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
CefBeforeDownloadCallbackImpl(const base::WeakPtr<DownloadManager>& manager,
uint32 download_id,
const base::FilePath& suggested_name,
const content::DownloadTargetCallback& callback)
content::DownloadTargetCallback callback)
: manager_(manager),
download_id_(download_id),
suggested_name_(suggested_name),
callback_(callback) {}
callback_(std::move(callback)) {}
void Continue(const CefString& download_path, bool show_dialog) override {
if (CEF_CURRENTLY_ON_UIT()) {
@ -56,28 +56,27 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
if (manager_) {
base::FilePath path = base::FilePath(download_path);
CEF_POST_USER_VISIBLE_TASK(base::Bind(
&CefBeforeDownloadCallbackImpl::GenerateFilename, manager_,
download_id_, suggested_name_, path, show_dialog, callback_));
CEF_POST_USER_VISIBLE_TASK(
base::BindOnce(&CefBeforeDownloadCallbackImpl::GenerateFilename,
manager_, download_id_, suggested_name_, path,
show_dialog, std::move(callback_)));
}
download_id_ = 0;
callback_.Reset();
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefBeforeDownloadCallbackImpl::Continue, this,
download_path, show_dialog));
base::BindOnce(&CefBeforeDownloadCallbackImpl::Continue,
this, download_path, show_dialog));
}
}
private:
static void GenerateFilename(
base::WeakPtr<DownloadManager> manager,
uint32 download_id,
const base::FilePath& suggested_name,
const base::FilePath& download_path,
bool show_dialog,
const content::DownloadTargetCallback& callback) {
static void GenerateFilename(base::WeakPtr<DownloadManager> manager,
uint32 download_id,
const base::FilePath& suggested_name,
const base::FilePath& download_path,
bool show_dialog,
content::DownloadTargetCallback callback) {
CEF_REQUIRE_BLOCKING();
base::FilePath suggested_path = download_path;
@ -103,16 +102,16 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
CEF_POST_TASK(
CEF_UIT,
base::Bind(&CefBeforeDownloadCallbackImpl::ChooseDownloadPath, manager,
download_id, suggested_path, show_dialog, callback));
base::BindOnce(&CefBeforeDownloadCallbackImpl::ChooseDownloadPath,
manager, download_id, suggested_path, show_dialog,
std::move(callback)));
}
static void ChooseDownloadPath(
base::WeakPtr<DownloadManager> manager,
uint32 download_id,
const base::FilePath& suggested_path,
bool show_dialog,
const content::DownloadTargetCallback& callback) {
static void ChooseDownloadPath(base::WeakPtr<DownloadManager> manager,
uint32 download_id,
const base::FilePath& suggested_path,
bool show_dialog,
content::DownloadTargetCallback callback) {
if (!manager)
return;
@ -142,21 +141,23 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
browser->RunFileChooser(
params,
base::Bind(
base::BindOnce(
&CefBeforeDownloadCallbackImpl::ChooseDownloadPathCallback,
callback));
std::move(callback)));
}
}
if (!handled) {
callback.Run(suggested_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, suggested_path,
download::DOWNLOAD_INTERRUPT_REASON_NONE);
std::move(callback).Run(
suggested_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
download::DownloadItem::MixedContentStatus::UNKNOWN, suggested_path,
download::DOWNLOAD_INTERRUPT_REASON_NONE);
}
}
static void ChooseDownloadPathCallback(
const content::DownloadTargetCallback& callback,
content::DownloadTargetCallback callback,
int selected_accept_filter,
const std::vector<base::FilePath>& file_paths) {
DCHECK_LE(file_paths.size(), (size_t)1);
@ -166,9 +167,10 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
path = file_paths.front();
// The download will be cancelled if |path| is empty.
callback.Run(path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path,
download::DOWNLOAD_INTERRUPT_REASON_NONE);
std::move(callback).Run(path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
download::DownloadItem::MixedContentStatus::UNKNOWN,
path, download::DOWNLOAD_INTERRUPT_REASON_NONE);
}
base::WeakPtr<DownloadManager> manager_;
@ -347,12 +349,13 @@ void CefDownloadManagerDelegate::ManagerGoingDown(DownloadManager* manager) {
bool CefDownloadManagerDelegate::DetermineDownloadTarget(
DownloadItem* item,
const content::DownloadTargetCallback& callback) {
content::DownloadTargetCallback* callback) {
if (!item->GetForcedFilePath().empty()) {
callback.Run(
std::move(*callback).Run(
item->GetForcedFilePath(), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, item->GetForcedFilePath(),
download::DOWNLOAD_INTERRUPT_REASON_NONE);
download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
download::DownloadItem::MixedContentStatus::UNKNOWN,
item->GetForcedFilePath(), download::DOWNLOAD_INTERRUPT_REASON_NONE);
return true;
}
@ -372,7 +375,7 @@ bool CefDownloadManagerDelegate::DetermineDownloadTarget(
CefRefPtr<CefBeforeDownloadCallback> callbackObj(
new CefBeforeDownloadCallbackImpl(manager_ptr_factory_.GetWeakPtr(),
item->GetId(), suggested_name,
callback));
std::move(*callback)));
handler->OnBeforeDownload(browser.get(), download_item.get(),
suggested_name.value(), callbackObj);
@ -384,9 +387,9 @@ bool CefDownloadManagerDelegate::DetermineDownloadTarget(
}
void CefDownloadManagerDelegate::GetNextId(
const content::DownloadIdCallback& callback) {
content::DownloadIdCallback callback) {
static uint32 next_id = DownloadItem::kInvalidId + 1;
callback.Run(next_id++);
std::move(callback).Run(next_id++);
}
std::string CefDownloadManagerDelegate::ApplicationClientIdForFileScanning() {

4
libcef/browser/download_manager_delegate.h
View File

@ -37,8 +37,8 @@ class CefDownloadManagerDelegate : public download::DownloadItem::Observer,
// DownloadManagerDelegate methods.
bool DetermineDownloadTarget(
download::DownloadItem* item,
const content::DownloadTargetCallback& callback) override;
void GetNextId(const content::DownloadIdCallback& callback) override;
content::DownloadTargetCallback* callback) override;
void GetNextId(content::DownloadIdCallback callback) override;
std::string ApplicationClientIdForFileScanning() override;
// CefBrowserHostImpl::Observer methods.

14
libcef/browser/extensions/extension_function_details.cc
View File

@ -44,10 +44,9 @@ class CefGetExtensionLoadFileCallbackImpl
if (CEF_CURRENTLY_ON_UIT()) {
RunNow(file_, std::move(callback_), nullptr);
} else {
CEF_POST_TASK(
CEF_UIT,
base::BindOnce(&CefGetExtensionLoadFileCallbackImpl::RunNow, file_,
base::Passed(std::move(callback_)), nullptr));
CEF_POST_TASK(CEF_UIT, base::BindOnce(
&CefGetExtensionLoadFileCallbackImpl::RunNow,
file_, std::move(callback_), nullptr));
}
}
}
@ -56,10 +55,9 @@ class CefGetExtensionLoadFileCallbackImpl
if (CEF_CURRENTLY_ON_UIT()) {
if (!callback_.is_null()) {
// Always continue asynchronously.
CEF_POST_TASK(
CEF_UIT,
base::BindOnce(&CefGetExtensionLoadFileCallbackImpl::RunNow, file_,
base::Passed(std::move(callback_)), stream));
CEF_POST_TASK(CEF_UIT, base::BindOnce(
&CefGetExtensionLoadFileCallbackImpl::RunNow,
file_, std::move(callback_), stream));
}
} else {
CEF_POST_TASK(CEF_UIT, base::BindOnce(

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

@ -44,6 +44,7 @@
#include "extensions/browser/runtime_data.h"
#include "extensions/browser/service_worker_manager.h"
#include "extensions/browser/state_store.h"
#include "extensions/browser/unloaded_extension_reason.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension_messages.h"
#include "extensions/common/file_util.h"
@ -96,9 +97,8 @@ void LoadExtensionOnUIThread(base::WeakPtr<CefExtensionSystem> context,
CefRefPtr<CefExtensionHandler> handler) {
if (!CEF_CURRENTLY_ON_UIT()) {
CEF_POST_TASK(CEF_UIT, base::BindOnce(LoadExtensionOnUIThread, context,
base::Passed(std::move(manifest)),
root_directory, internal,
loader_context, handler));
std::move(manifest), root_directory,
internal, loader_context, handler));
return;
}
@ -447,7 +447,7 @@ AppSorting* CefExtensionSystem::app_sorting() {
// ExtensionSystemImpl::RegisterExtensionWithRequestContexts.
void CefExtensionSystem::RegisterExtensionWithRequestContexts(
const Extension* extension,
const base::Closure& callback) {
base::OnceClosure callback) {
// TODO(extensions): The |incognito_enabled| value should be set based on
// manifest settings.
base::PostTaskAndReply(
@ -456,7 +456,7 @@ void CefExtensionSystem::RegisterExtensionWithRequestContexts(
base::RetainedRef(extension), base::Time::Now(),
true, // incognito_enabled
false), // notifications_disabled
callback);
std::move(callback));
}
// Implementation based on

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

@ -102,7 +102,7 @@ class CefExtensionSystem : public ExtensionSystem {
AppSorting* app_sorting() override;
void RegisterExtensionWithRequestContexts(
const Extension* extension,
const base::Closure& callback) override;
base::OnceClosure callback) override;
void UnregisterExtensionWithRequestContexts(
const std::string& extension_id,
const UnloadedExtensionReason reason) override;

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

@ -12,7 +12,7 @@
#include "extensions/browser/extension_system.h"
#include "extensions/browser/notification_types.h"
#include "extensions/browser/runtime_data.h"
#include "third_party/blink/public/platform/web_gesture_event.h"
#include "third_party/blink/public/common/input/web_gesture_event.h"
using content::NativeWebKeyboardEvent;
using content::OpenURLParams;

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

@ -32,7 +32,6 @@
#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/url_request_util.h"
#include "extensions/common/api/mime_handler.mojom.h"
#include "extensions/common/constants.h"
@ -307,14 +306,6 @@ void CefExtensionsBrowserClient::RegisterBrowserInterfaceBindersForFrame(
base::BindRepeating(&BindBeforeUnloadControl));
}
void CefExtensionsBrowserClient::RegisterExtensionInterfaces(
service_manager::BinderRegistryWithArgs<content::RenderFrameHost*>*
registry,
content::RenderFrameHost* render_frame_host,
const Extension* extension) const {
RegisterInterfacesForExtension(registry, render_frame_host, extension);
}
std::unique_ptr<RuntimeAPIDelegate>
CefExtensionsBrowserClient::CreateRuntimeAPIDelegate(
content::BrowserContext* context) const {

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

@ -86,10 +86,6 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
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,
const Extension* extension) const override;
std::unique_ptr<RuntimeAPIDelegate> CreateRuntimeAPIDelegate(
content::BrowserContext* context) const override;
const ComponentExtensionResourceManager*

114
libcef/browser/file_dialog_manager.cc
View File

@ -20,17 +20,20 @@ namespace {
class CefFileDialogCallbackImpl : public CefFileDialogCallback {
public:
explicit CefFileDialogCallbackImpl(
const CefFileDialogRunner::RunFileChooserCallback& callback)
: callback_(callback) {}
using CallbackType = CefFileDialogRunner::RunFileChooserCallback;
explicit CefFileDialogCallbackImpl(CallbackType callback)
: callback_(std::move(callback)) {}
~CefFileDialogCallbackImpl() override {
if (!callback_.is_null()) {
// The callback is still pending. Cancel it now.
if (CEF_CURRENTLY_ON_UIT()) {
CancelNow(callback_);
CancelNow(std::move(callback_));
} else {
CEF_POST_TASK(CEF_UIT, base::Bind(&CefFileDialogCallbackImpl::CancelNow,
callback_));
CEF_POST_TASK(CEF_UIT,
base::BindOnce(&CefFileDialogCallbackImpl::CancelNow,
std::move(callback_)));
}
}
}
@ -45,41 +48,36 @@ class CefFileDialogCallbackImpl : public CefFileDialogCallback {
for (; it != file_paths.end(); ++it)
vec.push_back(base::FilePath(*it));
}
callback_.Run(selected_accept_filter, vec);
callback_.Reset();
std::move(callback_).Run(selected_accept_filter, vec);
}
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefFileDialogCallbackImpl::Continue, this,
selected_accept_filter, file_paths));
base::BindOnce(&CefFileDialogCallbackImpl::Continue, this,
selected_accept_filter, file_paths));
}
}
void Cancel() override {
if (CEF_CURRENTLY_ON_UIT()) {
if (!callback_.is_null()) {
CancelNow(callback_);
callback_.Reset();
CancelNow(std::move(callback_));
}
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefFileDialogCallbackImpl::Cancel, this));
base::BindOnce(&CefFileDialogCallbackImpl::Cancel, this));
}
}
bool IsConnected() { return !callback_.is_null(); }
void Disconnect() { callback_.Reset(); }
CallbackType Disconnect() WARN_UNUSED_RESULT { return std::move(callback_); }
private:
static void CancelNow(
const CefFileDialogRunner::RunFileChooserCallback& callback) {
static void CancelNow(CallbackType callback) {
CEF_REQUIRE_UIT();
std::vector<base::FilePath> file_paths;
callback.Run(0, file_paths);
std::move(callback).Run(0, file_paths);
}
CefFileDialogRunner::RunFileChooserCallback callback_;
CallbackType callback_;
IMPLEMENT_REFCOUNTING(CefFileDialogCallbackImpl);
};
@ -99,16 +97,16 @@ class UploadFolderHelper
: public net::DirectoryLister::DirectoryListerDelegate {
public:
explicit UploadFolderHelper(
const CefFileDialogRunner::RunFileChooserCallback& callback)
: callback_(callback) {}
CefFileDialogRunner::RunFileChooserCallback callback)
: callback_(std::move(callback)) {}
~UploadFolderHelper() override {
if (!callback_.is_null()) {
if (CEF_CURRENTLY_ON_UIT()) {
CancelNow(callback_);
CancelNow(std::move(callback_));
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&UploadFolderHelper::CancelNow, callback_));
CEF_POST_TASK(CEF_UIT, base::BindOnce(&UploadFolderHelper::CancelNow,
std::move(callback_)));
}
}
}
@ -123,17 +121,15 @@ class UploadFolderHelper
void OnListDone(int error) override {
CEF_REQUIRE_UIT();
if (!callback_.is_null()) {
callback_.Run(0, select_files_);
callback_.Reset();
std::move(callback_).Run(0, select_files_);
}
}
private:
static void CancelNow(
const CefFileDialogRunner::RunFileChooserCallback& callback) {
static void CancelNow(CefFileDialogRunner::RunFileChooserCallback callback) {
CEF_REQUIRE_UIT();
std::vector<base::FilePath> file_paths;
callback.Run(0, file_paths);
std::move(callback).Run(0, file_paths);
}
CefFileDialogRunner::RunFileChooserCallback callback_;
@ -215,37 +211,35 @@ void CefFileDialogManager::RunFileChooser(
CefFileDialogRunner::RunFileChooserCallback callback;
if (params.mode == blink::mojom::FileChooserParams::Mode::kUploadFolder) {
callback = base::Bind(
callback = base::BindOnce(
&CefFileDialogManager::OnRunFileChooserUploadFolderDelegateCallback,
weak_ptr_factory_.GetWeakPtr(), params.mode,
base::Passed(std::move(listener)));
weak_ptr_factory_.GetWeakPtr(), params.mode, std::move(listener));
} else {
callback =
base::Bind(&CefFileDialogManager::OnRunFileChooserDelegateCallback,
weak_ptr_factory_.GetWeakPtr(), params.mode,
base::Passed(std::move(listener)));
callback = base::BindOnce(
&CefFileDialogManager::OnRunFileChooserDelegateCallback,
weak_ptr_factory_.GetWeakPtr(), params.mode, std::move(listener));
}
RunFileChooserInternal(cef_params, callback);
RunFileChooserInternal(cef_params, std::move(callback));
}
void CefFileDialogManager::RunFileChooser(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback) {
const CefFileDialogRunner::RunFileChooserCallback& host_callback =
base::Bind(&CefFileDialogManager::OnRunFileChooserCallback,
weak_ptr_factory_.GetWeakPtr(), callback);
RunFileChooserInternal(params, host_callback);
CefFileDialogRunner::RunFileChooserCallback callback) {
CefFileDialogRunner::RunFileChooserCallback host_callback =
base::BindOnce(&CefFileDialogManager::OnRunFileChooserCallback,
weak_ptr_factory_.GetWeakPtr(), std::move(callback));
RunFileChooserInternal(params, std::move(host_callback));
}
void CefFileDialogManager::RunFileChooserInternal(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback) {
CefFileDialogRunner::RunFileChooserCallback callback) {
CEF_REQUIRE_UIT();
if (file_chooser_pending_) {
// Dismiss the new dialog immediately.
callback.Run(0, std::vector<base::FilePath>());
std::move(callback).Run(0, std::vector<base::FilePath>());
return;
}
@ -289,35 +283,30 @@ void CefFileDialogManager::RunFileChooserInternal(
accept_filters.push_back(*it);
CefRefPtr<CefFileDialogCallbackImpl> callbackImpl(
new CefFileDialogCallbackImpl(callback));
new CefFileDialogCallbackImpl(std::move(callback)));
handled = handler->OnFileDialog(
browser_, static_cast<cef_file_dialog_mode_t>(mode), params.title,
params.default_file_name.value(), accept_filters,
params.selected_accept_filter, callbackImpl.get());
if (!handled) {
if (callbackImpl->IsConnected()) {
callbackImpl->Disconnect();
} else {
// User executed the callback even though they returned false.
NOTREACHED();
handled = true;
}
// May return nullptr if the client has already executed the callback.
callback = callbackImpl->Disconnect();
}
}
}
if (!handled) {
if (!handled && !callback.is_null()) {
if (runner_.get()) {
runner_->Run(browser_, params, callback);
runner_->Run(browser_, params, std::move(callback));
} else {
LOG(WARNING) << "No file dialog runner available for this platform";
callback.Run(0, std::vector<base::FilePath>());
std::move(callback).Run(0, std::vector<base::FilePath>());
}
}
}
void CefFileDialogManager::OnRunFileChooserCallback(
const CefFileDialogRunner::RunFileChooserCallback& callback,
CefFileDialogRunner::RunFileChooserCallback callback,
int selected_accept_filter,
const std::vector<base::FilePath>& file_paths) {
CEF_REQUIRE_UIT();
@ -325,8 +314,8 @@ void CefFileDialogManager::OnRunFileChooserCallback(
Cleanup();
// Execute the callback asynchronously.
CEF_POST_TASK(CEF_UIT,
base::Bind(callback, selected_accept_filter, file_paths));
CEF_POST_TASK(CEF_UIT, base::BindOnce(std::move(callback),
selected_accept_filter, file_paths));
}
void CefFileDialogManager::OnRunFileChooserUploadFolderDelegateCallback(
@ -344,10 +333,9 @@ void CefFileDialogManager::OnRunFileChooserUploadFolderDelegateCallback(
} else {
lister_.reset(new net::DirectoryLister(
file_paths[0], net::DirectoryLister::NO_SORT_RECURSIVE,
new UploadFolderHelper(
base::Bind(&CefFileDialogManager::OnRunFileChooserDelegateCallback,
weak_ptr_factory_.GetWeakPtr(), mode,
base::Passed(std::move(listener))))));
new UploadFolderHelper(base::BindOnce(
&CefFileDialogManager::OnRunFileChooserDelegateCallback,
weak_ptr_factory_.GetWeakPtr(), mode, std::move(listener)))));
lister_->Start();
}
}

9
libcef/browser/file_dialog_manager.h
View File

@ -52,19 +52,18 @@ class CefFileDialogManager {
// Run the file chooser dialog specified by |params|. Only a single dialog may
// be pending at any given time. |callback| will be executed asynchronously
// after the dialog is dismissed or if another dialog is already pending.
void RunFileChooser(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback);
void RunFileChooser(const CefFileDialogRunner::FileChooserParams& params,
CefFileDialogRunner::RunFileChooserCallback callback);
private:
void RunFileChooserInternal(
const CefFileDialogRunner::FileChooserParams& params,
const CefFileDialogRunner::RunFileChooserCallback& callback);
CefFileDialogRunner::RunFileChooserCallback callback);
// Used with the RunFileChooser variant where the caller specifies a callback
// (no associated RenderFrameHost).
void OnRunFileChooserCallback(
const CefFileDialogRunner::RunFileChooserCallback& callback,
CefFileDialogRunner::RunFileChooserCallback callback,
int selected_accept_filter,
const std::vector<base::FilePath>& file_paths);

2
libcef/browser/file_dialog_runner.h
View File

@ -30,7 +30,7 @@ class CefFileDialogRunner {
};
// The argument vector will be empty if the dialog was canceled.
typedef base::Callback<void(int, const std::vector<base::FilePath>&)>
typedef base::OnceCallback<void(int, const std::vector<base::FilePath>&)>
RunFileChooserCallback;
// Display the file chooser dialog. Execute |callback| on completion.

43
libcef/browser/javascript_dialog_manager.cc
View File

@ -19,17 +19,19 @@ namespace {
class CefJSDialogCallbackImpl : public CefJSDialogCallback {
public:
using Callback = content::JavaScriptDialogManager::DialogClosedCallback;
using CallbackType = content::JavaScriptDialogManager::DialogClosedCallback;
CefJSDialogCallbackImpl(Callback callback) : callback_(std::move(callback)) {}
CefJSDialogCallbackImpl(CallbackType callback)
: callback_(std::move(callback)) {}
~CefJSDialogCallbackImpl() override {
if (!callback_.is_null()) {
// The callback is still pending. Cancel it now.
if (CEF_CURRENTLY_ON_UIT()) {
CancelNow(std::move(callback_));
} else {
CEF_POST_TASK(CEF_UIT, base::Bind(&CefJSDialogCallbackImpl::CancelNow,
base::Passed(std::move(callback_))));
CEF_POST_TASK(CEF_UIT,
base::BindOnce(&CefJSDialogCallbackImpl::CancelNow,
std::move(callback_)));
}
}
}
@ -40,20 +42,20 @@ class CefJSDialogCallbackImpl : public CefJSDialogCallback {
std::move(callback_).Run(success, user_input);
}
} else {
CEF_POST_TASK(CEF_UIT, base::Bind(&CefJSDialogCallbackImpl::Continue,
this, success, user_input));
CEF_POST_TASK(CEF_UIT, base::BindOnce(&CefJSDialogCallbackImpl::Continue,
this, success, user_input));
}
}
Callback Disconnect() WARN_UNUSED_RESULT { return std::move(callback_); }
CallbackType Disconnect() WARN_UNUSED_RESULT { return std::move(callback_); }
private:
static void CancelNow(Callback callback) {
static void CancelNow(CallbackType callback) {
CEF_REQUIRE_UIT();
std::move(callback).Run(false, base::string16());
}
Callback callback_;
CallbackType callback_;
IMPLEMENT_REFCOUNTING(CefJSDialogCallbackImpl);
};
@ -130,11 +132,10 @@ void CefJavaScriptDialogManager::RunJavaScriptDialog(
url_formatter::FormatUrlForSecurityDisplay(origin_url);
DCHECK(!callback.is_null());
runner_->Run(browser_, message_type, display_url, message_text,
default_prompt_text,
base::Bind(&CefJavaScriptDialogManager::DialogClosed,
weak_ptr_factory_.GetWeakPtr(),
base::Passed(std::move(callback))));
runner_->Run(
browser_, message_type, display_url, message_text, default_prompt_text,
base::BindOnce(&CefJavaScriptDialogManager::DialogClosed,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void CefJavaScriptDialogManager::RunBeforeUnloadDialog(
@ -185,13 +186,13 @@ void CefJavaScriptDialogManager::RunBeforeUnloadDialog(
dialog_running_ = true;
DCHECK(!callback.is_null());
runner_->Run(browser_, content::JAVASCRIPT_DIALOG_TYPE_CONFIRM,
base::string16(), // display_url
message_text,
base::string16(), // default_prompt_text
base::Bind(&CefJavaScriptDialogManager::DialogClosed,
weak_ptr_factory_.GetWeakPtr(),
base::Passed(std::move(callback))));
runner_->Run(
browser_, content::JAVASCRIPT_DIALOG_TYPE_CONFIRM,
base::string16(), // display_url
message_text,
base::string16(), // default_prompt_text
base::BindOnce(&CefJavaScriptDialogManager::DialogClosed,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void CefJavaScriptDialogManager::CancelDialogs(

6
libcef/browser/javascript_dialog_runner.h
View File

@ -15,8 +15,8 @@ class CefBrowserHostImpl;
class CefJavaScriptDialogRunner {
public:
typedef base::Callback<void(bool /* success */,
const base::string16& /* user_input */)>
typedef base::OnceCallback<void(bool /* success */,
const base::string16& /* user_input */)>
DialogClosedCallback;
// Run the dialog. Execute |callback| on completion.
@ -25,7 +25,7 @@ class CefJavaScriptDialogRunner {
const base::string16& display_url,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback) = 0;
DialogClosedCallback callback) = 0;
// Cancel a dialog mid-flight.
virtual void Cancel() = 0;

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

@ -8,7 +8,7 @@
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/render_widget_host.h"
#include "third_party/blink/public/platform/web_mouse_event.h"
#include "third_party/blink/public/common/input/web_mouse_event.h"
CefBrowserPlatformDelegateNative::CefBrowserPlatformDelegateNative(
const CefWindowInfo& window_info,

6
libcef/browser/native/browser_platform_delegate_native_mac.mm
View File

@ -21,9 +21,9 @@
#include "content/public/browser/native_web_keyboard_event.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents.h"
#include "third_party/blink/public/platform/web_input_event.h"
#include "third_party/blink/public/platform/web_mouse_event.h"
#include "third_party/blink/public/platform/web_mouse_wheel_event.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/blink/public/common/input/web_mouse_event.h"
#include "third_party/blink/public/common/input/web_mouse_wheel_event.h"
#import "ui/base/cocoa/cocoa_base_utils.h"
#import "ui/base/cocoa/underlay_opengl_hosting_window.h"
#include "ui/events/base_event_utils.h"

4
libcef/browser/native/browser_platform_delegate_native_win.cc
View File

@ -22,8 +22,8 @@
#include "base/win/registry.h"
#include "base/win/win_util.h"
#include "content/public/browser/native_web_keyboard_event.h"
#include "third_party/blink/public/platform/web_mouse_event.h"
#include "third_party/blink/public/platform/web_mouse_wheel_event.h"
#include "third_party/blink/public/common/input/web_mouse_event.h"
#include "third_party/blink/public/common/input/web_mouse_wheel_event.h"
#include "ui/aura/window.h"
#include "ui/base/win/shell.h"
#include "ui/display/display.h"

19
libcef/browser/native/file_dialog_runner_mac.h
View File

@ -9,6 +9,10 @@
#include "libcef/browser/file_dialog_runner.h"
#include "base/memory/weak_ptr.h"
@class NSView;
class CefFileDialogRunnerMac : public CefFileDialogRunner {
public:
CefFileDialogRunnerMac();
@ -17,6 +21,21 @@ class CefFileDialogRunnerMac : public CefFileDialogRunner {
void Run(CefBrowserHostImpl* browser,
const FileChooserParams& params,
RunFileChooserCallback callback) override;
private:
static void RunOpenFileDialog(
base::WeakPtr<CefFileDialogRunnerMac> weak_this,
const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index);
static void RunSaveFileDialog(
base::WeakPtr<CefFileDialogRunnerMac> weak_this,
const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index);
CefFileDialogRunner::RunFileChooserCallback callback_;
base::WeakPtrFactory<CefFileDialogRunnerMac> weak_ptr_factory_;
};
#endif // CEF_LIBCEF_BROWSER_NATIVE_FILE_DIALOG_RUNNER_MAC_H_

77
libcef/browser/native/file_dialog_runner_mac.mm
View File

@ -229,12 +229,34 @@ void AddFilters(NSPopUpButton* button,
@end
namespace {
CefFileDialogRunnerMac::CefFileDialogRunnerMac() : weak_ptr_factory_(this) {}
void RunOpenFileDialog(const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index,
CefFileDialogRunner::RunFileChooserCallback callback) {
void CefFileDialogRunnerMac::Run(CefBrowserHostImpl* browser,
const FileChooserParams& params,
RunFileChooserCallback callback) {
callback_ = std::move(callback);
int filter_index = params.selected_accept_filter;
NSView* owner = CAST_CEF_WINDOW_HANDLE_TO_NSVIEW(browser->GetWindowHandle());
auto weak_this = weak_ptr_factory_.GetWeakPtr();
if (params.mode == blink::mojom::FileChooserParams::Mode::kOpen ||
params.mode == blink::mojom::FileChooserParams::Mode::kOpenMultiple ||
params.mode == blink::mojom::FileChooserParams::Mode::kUploadFolder) {
RunOpenFileDialog(weak_this, params, owner, filter_index);
} else if (params.mode == blink::mojom::FileChooserParams::Mode::kSave) {
RunSaveFileDialog(weak_this, params, owner, filter_index);
} else {
NOTIMPLEMENTED();
}
}
// static
void CefFileDialogRunnerMac::RunOpenFileDialog(
base::WeakPtr<CefFileDialogRunnerMac> weak_this,
const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index) {
NSOpenPanel* openPanel = [NSOpenPanel openPanel];
base::string16 title;
@ -308,18 +330,21 @@ void RunOpenFileDialog(const CefFileDialogRunner::FileChooserParams& params,
if (url.isFileURL)
files.push_back(base::FilePath(url.path.UTF8String));
}
callback.Run(filter_index_to_use, files);
std::move(weak_this->callback_)
.Run(filter_index_to_use, files);
} else {
callback.Run(filter_index_to_use,
std::vector<base::FilePath>());
std::move(weak_this->callback_)
.Run(filter_index_to_use, std::vector<base::FilePath>());
}
}];
}
void RunSaveFileDialog(const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index,
CefFileDialogRunner::RunFileChooserCallback callback) {
// static
void CefFileDialogRunnerMac::RunSaveFileDialog(
base::WeakPtr<CefFileDialogRunnerMac> weak_this,
const CefFileDialogRunner::FileChooserParams& params,
NSView* view,
int filter_index) {
NSSavePanel* savePanel = [NSSavePanel savePanel];
base::string16 title;
@ -371,31 +396,11 @@ void RunSaveFileDialog(const CefFileDialogRunner::FileChooserParams& params,
NSURL* url = savePanel.URL;
const char* path = url.path.UTF8String;
std::vector<base::FilePath> files(1, base::FilePath(path));
callback.Run(filter_index_to_use, files);
std::move(weak_this->callback_)
.Run(filter_index_to_use, files);
} else {
callback.Run(filter_index_to_use,
std::vector<base::FilePath>());
std::move(weak_this->callback_)
.Run(filter_index_to_use, std::vector<base::FilePath>());
}
}];
}
} // namespace
CefFileDialogRunnerMac::CefFileDialogRunnerMac() {}
void CefFileDialogRunnerMac::Run(CefBrowserHostImpl* browser,
const FileChooserParams& params,
RunFileChooserCallback callback) {
int filter_index = params.selected_accept_filter;
NSView* owner = CAST_CEF_WINDOW_HANDLE_TO_NSVIEW(browser->GetWindowHandle());
if (params.mode == blink::mojom::FileChooserParams::Mode::kOpen ||
params.mode == blink::mojom::FileChooserParams::Mode::kOpenMultiple ||
params.mode == blink::mojom::FileChooserParams::Mode::kUploadFolder) {
RunOpenFileDialog(params, owner, filter_index, callback);
} else if (params.mode == blink::mojom::FileChooserParams::Mode::kSave) {
RunSaveFileDialog(params, owner, filter_index, callback);
} else {
NOTIMPLEMENTED();
}
}

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

@ -520,5 +520,5 @@ void CefFileDialogRunnerWin::Run(CefBrowserHostImpl* browser,
NOTIMPLEMENTED();
}
callback.Run(filter_index, files);
std::move(callback).Run(filter_index, files);
}

2
libcef/browser/native/javascript_dialog_runner_mac.h
View File

@ -29,7 +29,7 @@ class CefJavaScriptDialogRunnerMac : public CefJavaScriptDialogRunner {
const base::string16& display_url,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback) override;
DialogClosedCallback callback) override;
void Cancel() override;
// Callback from CefJavaScriptDialogHelper when the dialog is closed.

12
libcef/browser/native/javascript_dialog_runner_mac.mm
View File

@ -38,7 +38,7 @@
- (id)initHelperWithCallback:
(CefJavaScriptDialogRunner::DialogClosedCallback)callback {
if (self = [super init])
callback_ = callback;
callback_ = std::move(callback);
return self;
}
@ -69,7 +69,7 @@
if (textField_)
input = base::SysNSStringToUTF16([textField_ stringValue]);
callback_.Run(success, input);
std::move(callback_).Run(success, input);
}
- (void)cancel {
@ -92,15 +92,15 @@ void CefJavaScriptDialogRunnerMac::Run(
const base::string16& display_url,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback) {
DialogClosedCallback callback) {
DCHECK(!helper_.get());
callback_ = callback;
callback_ = std::move(callback);
bool text_field = message_type == content::JAVASCRIPT_DIALOG_TYPE_PROMPT;
bool one_button = message_type == content::JAVASCRIPT_DIALOG_TYPE_ALERT;
helper_.reset([[CefJavaScriptDialogHelper alloc]
initHelperWithCallback:base::Bind(
initHelperWithCallback:base::BindOnce(
&CefJavaScriptDialogRunnerMac::DialogClosed,
weak_ptr_factory_.GetWeakPtr())]);
@ -167,5 +167,5 @@ void CefJavaScriptDialogRunnerMac::DialogClosed(
bool success,
const base::string16& user_input) {
helper_.reset(nil);
callback_.Run(success, user_input);
std::move(callback_).Run(success, user_input);
}

7
libcef/browser/native/javascript_dialog_runner_win.cc
View File

@ -96,13 +96,13 @@ void CefJavaScriptDialogRunnerWin::Run(
const base::string16& display_url,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback) {
DialogClosedCallback callback) {
DCHECK(!dialog_win_);
message_type_ = message_type;
message_text_ = message_text;
default_prompt_text_ = default_prompt_text;
callback_ = callback;
callback_ = std::move(callback);
InstallMessageHook();
hook_installed_ = true;
@ -177,8 +177,7 @@ void CefJavaScriptDialogRunnerWin::CloseDialog(
// cleared. Otherwise, RenderWidgetHostImpl::IsIgnoringInputEvents will
// return true and RenderWidgetHostViewAura::OnWindowFocused will fail to
// re-assign browser focus.
callback_.Run(success, user_input);
callback_.Reset();
std::move(callback_).Run(success, user_input);
Cancel();
}

2
libcef/browser/native/javascript_dialog_runner_win.h
View File

@ -22,7 +22,7 @@ class CefJavaScriptDialogRunnerWin : public CefJavaScriptDialogRunner {
const base::string16& display_url,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback) override;
DialogClosedCallback callback) override;
void Cancel() override;
private:

2
libcef/browser/navigate_params.h
View File

@ -37,7 +37,7 @@ struct CefNavigateParams {
// lead to undesired cookie blocking. Third-party cookie blocking can be
// bypassed by setting site_for_cookies = url, but this should ideally
// only be done if there really is no way to determine the correct value.
GURL site_for_cookies;
net::SiteForCookies site_for_cookies;
// Additional HTTP request headers.
std::string headers;

2
libcef/browser/net/crlset_file_util_impl.cc
View File

@ -17,7 +17,7 @@ namespace {
void UpdateCRLSet(const std::string& crl_set_bytes) {
CEF_REQUIRE_UIT();
content::GetNetworkService()->UpdateCRLSet(
base::as_bytes(base::make_span(crl_set_bytes)));
base::as_bytes(base::make_span(crl_set_bytes)), base::DoNothing());
}
void LoadFromDisk(const base::FilePath& path) {

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

@ -280,7 +280,7 @@ class CefBrowserURLRequest::Context
// Associate the request with |request_id|.
request_id_ = request_id;
loader_->SetRequestId(request_id);
loader_->SetRequestID(request_id);
g_manager.Get().Add(request_id, url_request_, client_);
if (request_body) {

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

@ -15,7 +15,6 @@
#include "net/cookies/cookie_util.h"
#include "services/network/cookie_manager.h"
#include "services/network/public/cpp/resource_request.h"
#include "services/network/public/cpp/resource_response.h"
namespace net_service {
@ -169,14 +168,14 @@ void LoadCookies(content::BrowserContext* browser_context,
void SaveCookies(content::BrowserContext* browser_context,
const network::ResourceRequest& request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
const AllowCookieCallback& allow_cookie_callback,
DoneCookieCallback done_callback) {
CEF_REQUIRE_IOT();
if (request.credentials_mode == network::mojom::CredentialsMode::kOmit ||
request.url.IsAboutBlank() || !head.headers ||
!head.headers->HasHeader(net_service::kHTTPSetCookieHeaderName)) {
request.url.IsAboutBlank() || !headers ||
!headers->HasHeader(net_service::kHTTPSetCookieHeaderName)) {
// Continue immediately without saving cookies.
std::move(done_callback).Run(0, {});
return;
@ -185,7 +184,7 @@ void SaveCookies(content::BrowserContext* browser_context,
// Match the logic in
// URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete.
base::Time response_date;
if (!head.headers->GetDateValue(&response_date))
if (!headers->GetDateValue(&response_date))
response_date = base::Time();
net::CookieOptions options;
@ -201,7 +200,7 @@ void SaveCookies(content::BrowserContext* browser_context,
net::CookieList allowed_cookies;
int total_count = 0;
while (head.headers->EnumerateHeader(&iter, name, &cookie_string)) {
while (headers->EnumerateHeader(&iter, name, &cookie_string)) {
total_count++;
net::CanonicalCookie::CookieInclusionStatus returned_status;

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

@ -12,9 +12,12 @@ namespace content {
class BrowserContext;
}
namespace net {
class HttpResponseHeaders;
}
namespace network {
struct ResourceRequest;
struct ResourceResponseHead;
} // namespace network
namespace net_service {
@ -45,7 +48,7 @@ void LoadCookies(content::BrowserContext* browser_context,
// on the IO thread.
void SaveCookies(content::BrowserContext* browser_context,
const network::ResourceRequest& request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
const AllowCookieCallback& allow_cookie_callback,
DoneCookieCallback done_callback);

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

@ -11,7 +11,7 @@
#include "base/barrier_closure.h"
#include "base/strings/string_number_conversions.h"
#include "components/safe_browsing/common/safebrowsing_constants.h"
#include "components/safe_browsing/core/common/safebrowsing_constants.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/resource_context.h"
@ -245,7 +245,8 @@ class InterceptedRequest : public network::mojom::URLLoader,
bool waiting_for_upload_progress_ack_ = false;
network::ResourceRequest request_;
network::ResourceResponseHead current_response_;
network::mojom::URLResponseHeadPtr current_response_;
scoped_refptr<net::HttpResponseHeaders> current_headers_;
scoped_refptr<net::HttpResponseHeaders> override_headers_;
GURL original_url_;
GURL redirect_url_;
@ -426,16 +427,15 @@ void InterceptedRequest::OnHeadersReceived(
return;
}
current_response_.headers =
base::MakeRefCounted<net::HttpResponseHeaders>(headers);
current_headers_ = base::MakeRefCounted<net::HttpResponseHeaders>(headers);
on_headers_received_callback_ = std::move(callback);
base::Optional<net::RedirectInfo> redirect_info;
std::string location;
if (current_response_.headers->IsRedirect(&location)) {
if (current_headers_->IsRedirect(&location)) {
const GURL new_url = request_.url.Resolve(location);
redirect_info =
MakeRedirectInfo(request_, current_response_.headers.get(), new_url, 0);
MakeRedirectInfo(request_, current_headers_.get(), new_url, 0);
}
HandleResponseOrRedirectHeaders(
@ -448,16 +448,16 @@ void InterceptedRequest::OnHeadersReceived(
void InterceptedRequest::OnReceiveResponse(
network::mojom::URLResponseHeadPtr head) {
current_response_ = std::move(head);
if (current_request_uses_header_client_) {
// Use the headers we got from OnHeadersReceived as that'll contain
// Set-Cookie if it existed.
auto saved_headers = current_response_.headers;
DCHECK(saved_headers);
current_response_ = head;
current_response_.headers = saved_headers;
DCHECK(current_headers_);
current_response_->headers = current_headers_;
current_headers_ = nullptr;
ContinueToResponseStarted(net::OK);
} else {
current_response_ = head;
HandleResponseOrRedirectHeaders(
base::nullopt,
base::BindOnce(&InterceptedRequest::ContinueToResponseStarted,
@ -470,16 +470,15 @@ void InterceptedRequest::OnReceiveRedirect(
network::mojom::URLResponseHeadPtr head) {
bool needs_callback = false;
current_response_ = std::move(head);
if (current_request_uses_header_client_) {
// Use the headers we got from OnHeadersReceived as that'll contain
// Set-Cookie if it existed. May be null for synthetic redirects.
auto saved_headers = current_response_.headers;
current_response_ = head;
if (saved_headers) {
current_response_.headers = saved_headers;
}
DCHECK(current_headers_);
current_response_->headers = current_headers_;
current_headers_ = nullptr;
} else {
current_response_ = head;
needs_callback = true;
}
@ -625,33 +624,35 @@ void InterceptedRequest::InterceptResponseReceived(
DCHECK(!response);
// Perform the redirect.
network::ResourceResponseHead head;
head.request_start = base::TimeTicks::Now();
head.response_start = base::TimeTicks::Now();
head.headers = MakeResponseHeaders(
current_response_ = network::mojom::URLResponseHead::New();
current_response_->request_start = base::TimeTicks::Now();
current_response_->response_start = base::TimeTicks::Now();
auto headers = MakeResponseHeaders(
net::HTTP_TEMPORARY_REDIRECT, std::string(), std::string(),
std::string(), -1, {}, false /* allow_existing_header_override */);
current_response_->headers = headers;
head.encoded_data_length = head.headers->raw_headers().length();
head.content_length = head.encoded_body_length = 0;
current_response_->encoded_data_length = headers->raw_headers().length();
current_response_->content_length = current_response_->encoded_body_length =
0;
std::string origin;
if (request_.headers.GetHeader(net::HttpRequestHeaders::kOrigin, &origin) &&
origin != url::Origin().Serialize()) {
// Allow redirects of cross-origin resource loads.
head.headers->AddHeader(MakeHeader(
headers->AddHeader(MakeHeader(
network::cors::header_names::kAccessControlAllowOrigin, origin));
}
if (request_.credentials_mode ==
network::mojom::CredentialsMode::kInclude) {
head.headers->AddHeader(MakeHeader(
headers->AddHeader(MakeHeader(
network::cors::header_names::kAccessControlAllowCredentials, "true"));
}
current_response_ = head;
const net::RedirectInfo& redirect_info =
MakeRedirectInfo(request_, head.headers.get(), request_.url, 0);
MakeRedirectInfo(request_, headers.get(), request_.url, 0);
HandleResponseOrRedirectHeaders(
redirect_info,
base::BindOnce(&InterceptedRequest::ContinueToBeforeRedirect,
@ -715,17 +716,21 @@ void InterceptedRequest::HandleResponseOrRedirectHeaders(
redirect_url_ = redirect_info.has_value() ? redirect_info->new_url : GURL();
original_url_ = request_.url;
// |current_response_| may be nullptr when called from OnHeadersReceived.
auto headers =
current_response_ ? current_response_->headers : current_headers_;
// Even though |head| is const we can get a non-const pointer to the headers
// and modifications we make are passed to the target client.
factory_->request_handler_->ProcessResponseHeaders(
id_, request_, redirect_url_, current_response_);
id_, request_, redirect_url_, headers.get());
// Pause handling of client messages before waiting on an async callback.
if (proxied_client_binding_)
proxied_client_binding_.PauseIncomingMethodCallProcessing();
factory_->request_handler_->OnRequestResponse(
id_, &request_, current_response_, redirect_info,
id_, &request_, headers.get(), redirect_info,
base::BindOnce(&InterceptedRequest::ContinueResponseOrRedirect,
weak_factory_.GetWeakPtr(), std::move(continuation)));
}
@ -749,7 +754,7 @@ void InterceptedRequest::ContinueResponseOrRedirect(
// Make sure to update current_response_, since when OnReceiveResponse
// is called we will not use its headers as it might be missing the
// Set-Cookie line (which gets stripped by the IPC layer).
current_response_.headers = override_headers_;
current_response_->headers = override_headers_;
}
redirect_url_ = redirect_url;
@ -780,21 +785,22 @@ void InterceptedRequest::ContinueToHandleOverrideHeaders(int error_code) {
net::RedirectInfo InterceptedRequest::MakeRedirectResponseAndInfo(
const GURL& new_location) {
// Clear the Content-Type values.
current_response_.mime_type = current_response_.charset = std::string();
current_response_.headers->RemoveHeader(
current_response_->mime_type = current_response_->charset = std::string();
current_response_->headers->RemoveHeader(
net::HttpRequestHeaders::kContentType);
// Clear the Content-Length values.
current_response_.content_length = current_response_.encoded_body_length = 0;
current_response_.headers->RemoveHeader(
current_response_->content_length = current_response_->encoded_body_length =
0;
current_response_->headers->RemoveHeader(
net::HttpRequestHeaders::kContentLength);
current_response_.encoded_data_length =
current_response_.headers->raw_headers().size();
current_response_->encoded_data_length =
current_response_->headers->raw_headers().size();
const net::RedirectInfo& redirect_info = MakeRedirectInfo(
request_, current_response_.headers.get(), new_location, 0);
current_response_.headers->ReplaceStatusLine(
request_, current_response_->headers.get(), new_location, 0);
current_response_->headers->ReplaceStatusLine(
MakeStatusLine(redirect_info.status_code, std::string(), true));
return redirect_info;
@ -824,10 +830,12 @@ void InterceptedRequest::ContinueToBeforeRedirect(
if (redirect_url.is_valid()) {
net::RedirectInfo new_redirect_info = redirect_info;
new_redirect_info.new_url = redirect_url;
target_client_->OnReceiveRedirect(new_redirect_info, current_response_);
target_client_->OnReceiveRedirect(new_redirect_info,
std::move(current_response_));
request_.url = redirect_url;
} else {
target_client_->OnReceiveRedirect(redirect_info, current_response_);
target_client_->OnReceiveRedirect(redirect_info,
std::move(current_response_));
request_.url = redirect_info.new_url;
}
@ -854,8 +862,8 @@ void InterceptedRequest::ContinueToResponseStarted(int error_code) {
std::string location;
const bool is_redirect = redirect_url.is_valid() ||
(current_response_.headers &&
current_response_.headers->IsRedirect(&location));
(current_response_->headers &&
current_response_->headers->IsRedirect(&location));
if (stream_loader_ && is_redirect) {
// Redirecting from OnReceiveResponse generally isn't supported by the
// NetworkService, so we can only support it when using a custom loader.
@ -879,7 +887,7 @@ void InterceptedRequest::ContinueToResponseStarted(int error_code) {
if (proxied_client_binding_)
proxied_client_binding_.ResumeIncomingMethodCallProcessing();
target_client_->OnReceiveResponse(current_response_);
target_client_->OnReceiveResponse(std::move(current_response_));
}
if (stream_loader_)
@ -1012,7 +1020,7 @@ void InterceptedRequestHandler::ShouldInterceptRequest(
void InterceptedRequestHandler::OnRequestResponse(
const RequestId& id,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
base::Optional<net::RedirectInfo> redirect_info,
OnRequestResponseResultCallback callback) {
std::move(callback).Run(

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

@ -18,7 +18,6 @@
#include "content/public/browser/web_contents.h"
#include "mojo/public/cpp/bindings/binding_set.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "services/network/public/cpp/resource_response.h"
#include "services/network/public/mojom/network_context.mojom.h"
#include "services/network/public/mojom/url_loader_factory.mojom.h"
@ -76,11 +75,10 @@ class InterceptedRequestHandler {
// method is called in response to a redirect. Even though |head| is const the
// |head.headers| value is non-const and any changes will be passed to the
// client.
virtual void ProcessResponseHeaders(
const RequestId& id,
const network::ResourceRequest& request,
const GURL& redirect_url,
const network::ResourceResponseHead& head) {}
virtual void ProcessResponseHeaders(const RequestId& id,
const network::ResourceRequest& request,
const GURL& redirect_url,
net::HttpResponseHeaders* headers) {}
enum class ResponseMode {
// Continue the request.
@ -101,7 +99,7 @@ class InterceptedRequestHandler {
virtual void OnRequestResponse(
const RequestId& id,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
base::Optional<net::RedirectInfo> redirect_info,
OnRequestResponseResultCallback callback);

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

@ -592,7 +592,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
new RequestCallbackWrapper(base::BindOnce(
&InterceptedRequestHandlerWrapper::ContinueShouldInterceptRequest,
weak_ptr_factory_.GetWeakPtr(), id, base::Unretained(request),
base::Passed(std::move(callback))));
std::move(callback)));
cef_return_value_t retval = state->handler_->OnBeforeResourceLoad(
init_state_->browser_, init_state_->frame_,
@ -687,11 +687,10 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
std::move(callback).Run(std::move(resource_response));
}
void ProcessResponseHeaders(
const RequestId& id,
const network::ResourceRequest& request,
const GURL& redirect_url,
const network::ResourceResponseHead& head) override {
void ProcessResponseHeaders(const RequestId& id,
const network::ResourceRequest& request,
const GURL& redirect_url,
net::HttpResponseHeaders* headers) override {
CEF_REQUIRE_IOT();
RequestState* state = GetState(id);
@ -708,15 +707,15 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
else
state->pending_response_->SetReadOnly(false);
if (head.headers)
state->pending_response_->SetResponseHeaders(*head.headers);
if (headers)
state->pending_response_->SetResponseHeaders(*headers);
state->pending_response_->SetReadOnly(true);
}
void OnRequestResponse(const RequestId& id,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
base::Optional<net::RedirectInfo> redirect_info,
OnRequestResponseResultCallback callback) override {
CEF_REQUIRE_IOT();
@ -735,7 +734,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
if (!state->handler_) {
// Cookies may come from a scheme handler.
MaybeSaveCookies(
id, state, request, head,
id, state, request, headers,
base::BindOnce(
std::move(callback), ResponseMode::CONTINUE, nullptr,
redirect_info.has_value() ? redirect_info->new_url : GURL()));
@ -746,17 +745,17 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
DCHECK(state->pending_response_);
if (redirect_info.has_value()) {
HandleRedirect(id, state, request, head, *redirect_info,
HandleRedirect(id, state, request, headers, *redirect_info,
std::move(callback));
} else {
HandleResponse(id, state, request, head, std::move(callback));
HandleResponse(id, state, request, headers, std::move(callback));
}
}
void HandleRedirect(const RequestId& id,
RequestState* state,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
const net::RedirectInfo& redirect_info,
OnRequestResponseResultCallback callback) {
GURL new_url = redirect_info.new_url;
@ -786,13 +785,13 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
auto exec_callback = base::BindOnce(
std::move(callback), ResponseMode::CONTINUE, nullptr, new_url);
MaybeSaveCookies(id, state, request, head, std::move(exec_callback));
MaybeSaveCookies(id, state, request, headers, std::move(exec_callback));
}
void HandleResponse(const RequestId& id,
RequestState* state,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
OnRequestResponseResultCallback callback) {
// The client may modify |pending_request_| in OnResourceResponse.
state->pending_request_->SetReadOnly(false);
@ -835,13 +834,13 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
return;
}
MaybeSaveCookies(id, state, request, head, std::move(exec_callback));
MaybeSaveCookies(id, state, request, headers, std::move(exec_callback));
}
void MaybeSaveCookies(const RequestId& id,
RequestState* state,
network::ResourceRequest* request,
const network::ResourceResponseHead& head,
net::HttpResponseHeaders* headers,
base::OnceClosure callback) {
CEF_REQUIRE_IOT();
@ -863,7 +862,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
auto done_cookie_callback = base::BindOnce(
&InterceptedRequestHandlerWrapper::ContinueWithSavedCookies,
weak_ptr_factory_.GetWeakPtr(), id, std::move(callback));
net_service::SaveCookies(init_state_->browser_context_, *request, head,
net_service::SaveCookies(init_state_->browser_context_, *request, headers,
allow_cookie_callback,
std::move(done_cookie_callback));
}

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

@ -420,8 +420,8 @@ void InputStreamReader::RunSkipCallback(int64_t bytes_skipped) {
DCHECK(!pending_skip_callback_.is_null());
job_thread_task_runner_->PostTask(
FROM_HERE,
base::Bind(InputStreamReader::RunSkipCallbackOnJobThread, bytes_skipped,
base::Passed(std::move(pending_skip_callback_))));
base::BindOnce(InputStreamReader::RunSkipCallbackOnJobThread,
bytes_skipped, std::move(pending_skip_callback_)));
// Reset callback state.
pending_callback_id_ = -1;
@ -433,9 +433,8 @@ void InputStreamReader::RunReadCallback(int bytes_read) {
DCHECK(!pending_read_callback_.is_null());
job_thread_task_runner_->PostTask(
FROM_HERE,
base::Bind(InputStreamReader::RunReadCallbackOnJobThread, bytes_read,
base::Passed(std::move(pending_read_callback_))));
FROM_HERE, base::BindOnce(InputStreamReader::RunReadCallbackOnJobThread,
bytes_read, std::move(pending_read_callback_)));
// Reset callback state.
pending_callback_id_ = -1;
@ -640,32 +639,38 @@ void StreamReaderURLLoader::HeadersComplete(int orig_status_code,
return;
}
pending_response_.request_start = base::TimeTicks::Now();
pending_response_.response_start = base::TimeTicks::Now();
pending_response_.headers = MakeResponseHeaders(
auto pending_response = network::mojom::URLResponseHead::New();
pending_response->request_start = base::TimeTicks::Now();
pending_response->response_start = base::TimeTicks::Now();
auto headers = MakeResponseHeaders(
status_code, status_text, mime_type, charset, content_length,
extra_headers, false /* allow_existing_header_override */);
pending_response->headers = headers;
if (content_length >= 0)
pending_response_.content_length = content_length;
pending_response->content_length = content_length;
if (!mime_type.empty()) {
pending_response_.mime_type = mime_type;
pending_response->mime_type = mime_type;
if (!charset.empty())
pending_response_.charset = charset;
pending_response->charset = charset;
}
if (header_client_.is_bound()) {
header_client_->OnHeadersReceived(
pending_response_.headers->raw_headers(), net::IPEndPoint(),
headers->raw_headers(), net::IPEndPoint(),
base::BindOnce(&StreamReaderURLLoader::ContinueWithResponseHeaders,
weak_factory_.GetWeakPtr()));
weak_factory_.GetWeakPtr(),
std::move(pending_response)));
} else {
ContinueWithResponseHeaders(net::OK, base::nullopt, GURL());
ContinueWithResponseHeaders(std::move(pending_response), net::OK,
base::nullopt, base::nullopt);
}
}
void StreamReaderURLLoader::ContinueWithResponseHeaders(
network::mojom::URLResponseHeadPtr pending_response,
int32_t result,
const base::Optional<std::string>& headers,
const base::Optional<GURL>& redirect_url) {
@ -676,34 +681,35 @@ void StreamReaderURLLoader::ContinueWithResponseHeaders(
if (headers) {
DCHECK(header_client_.is_bound());
pending_response_.headers =
pending_response->headers =
base::MakeRefCounted<net::HttpResponseHeaders>(*headers);
}
auto pending_headers = pending_response->headers;
// What the length would be if we sent headers over the network. Used to
// calculate data length.
header_length_ = pending_response_.headers->raw_headers().length();
header_length_ = pending_headers->raw_headers().length();
DCHECK(client_.is_bound());
std::string 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 =
if (has_redirect_url || pending_headers->IsRedirect(&location)) {
pending_response->encoded_data_length = header_length_;
pending_response->content_length = pending_response->encoded_body_length =
0;
const GURL new_location =
has_redirect_url ? *redirect_url : request_.url.Resolve(location);
client_->OnReceiveRedirect(
MakeRedirectInfo(request_, pending_response_.headers.get(),
new_location,
pending_response_.headers->response_code()),
pending_response_);
MakeRedirectInfo(request_, pending_headers.get(), new_location,
pending_headers->response_code()),
std::move(pending_response));
// The client will restart the request with a new loader.
// |this| will be deleted.
CleanUp();
} else {
client_->OnReceiveResponse(pending_response_);
client_->OnReceiveResponse(std::move(pending_response));
}
}

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

@ -13,9 +13,9 @@
#include "mojo/public/cpp/system/simple_watcher.h"
#include "net/http/http_byte_range.h"
#include "services/network/public/cpp/net_adapters.h"
#include "services/network/public/cpp/resource_response.h"
#include "services/network/public/mojom/network_context.mojom.h"
#include "services/network/public/mojom/url_loader.mojom.h"
#include "services/network/public/mojom/url_response_head.mojom.h"
namespace net_service {
@ -188,9 +188,11 @@ class StreamReaderURLLoader : public network::mojom::URLLoader {
void OnReaderSkipCompleted(int64_t bytes_skipped);
void HeadersComplete(int status_code, int64_t expected_content_length);
void ContinueWithResponseHeaders(int32_t result,
const base::Optional<std::string>& headers,
const base::Optional<GURL>& redirect_url);
void ContinueWithResponseHeaders(
network::mojom::URLResponseHeadPtr pending_response,
int32_t result,
const base::Optional<std::string>& headers,
const base::Optional<GURL>& redirect_url);
void SendBody();
void ReadMore();
@ -205,8 +207,6 @@ class StreamReaderURLLoader : public network::mojom::URLLoader {
const RequestId request_id_;
network::ResourceResponseHead pending_response_;
size_t header_length_ = 0;
int64_t total_bytes_read_ = 0;

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

@ -64,7 +64,8 @@ scoped_refptr<URLLoaderFactoryGetter> URLLoaderFactoryGetter::Create(
content::ContentBrowserClient::URLLoaderFactoryType::kDocumentSubResource,
url::Origin(), base::nullopt /* navigation_id */,
&maybe_proxy_factory_request, nullptr /* header_client */,
nullptr /* bypass_redirect_checks */, nullptr /* factory_override */);
nullptr /* bypass_redirect_checks */, nullptr /* disable_secure_dns */,
nullptr /* factory_override */);
// If anyone above indicated that they care about proxying, pass the
// intermediate pipe along to the URLLoaderFactoryGetter.

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

@ -9,7 +9,7 @@
#include "include/cef_base.h"
#include "third_party/blink/public/platform/web_touch_event.h"
#include "third_party/blink/public/common/input/web_touch_event.h"
#include "ui/events/gesture_detection/motion_event_generic.h"
// Implementation of MotionEvent which takes a stream of CefTouchEvents.

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

@ -103,7 +103,7 @@ struct PopulateAxNodeAttributes {
case ax::mojom::IntAttribute::kActivedescendantId:
case ax::mojom::IntAttribute::kInPageLinkTargetId:
case ax::mojom::IntAttribute::kErrormessageId:
case ax::mojom::IntAttribute::kDetailsId:
case ax::mojom::IntAttribute::kDOMNodeId:
case ax::mojom::IntAttribute::kDropeffect:
case ax::mojom::IntAttribute::kMemberOfId:
case ax::mojom::IntAttribute::kNextFocusId:

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

@ -64,7 +64,7 @@ const size_t kMaxDamageRects = 10;
const float kDefaultScaleFactor = 1.0;
static content::ScreenInfo ScreenInfoFrom(const CefScreenInfo& src) {
content::ScreenInfo ScreenInfoFrom(const CefScreenInfo& src) {
content::ScreenInfo screenInfo;
screenInfo.device_scale_factor = src.device_scale_factor;
screenInfo.depth = src.depth;
@ -104,12 +104,6 @@ class CefDelegatedFrameHostClient : public content::DelegatedFrameHostClient {
return *view_->GetBackgroundColor();
}
void OnBeginFrame(base::TimeTicks frame_time) override {
// TODO(cef): Maybe we can use this method in combination with
// OnSetNeedsBeginFrames() instead of using CefBeginFrameTimer.
// See https://codereview.chromium.org/1841083007.
}
void OnFrameTokenChanged(uint32_t frame_token) override {
view_->render_widget_host()->DidProcessFrame(frame_token);
}
@ -179,6 +173,23 @@ float GetDeviceScaleFactor(CefBrowserHostImpl* browser) {
return screen_info.device_scale_factor;
}
ui::ImeTextSpan::UnderlineStyle GetImeUnderlineStyle(
cef_composition_underline_style_t style) {
switch (style) {
case CEF_CUS_SOLID:
return ui::ImeTextSpan::UnderlineStyle::kSolid;
case CEF_CUS_DOT:
return ui::ImeTextSpan::UnderlineStyle::kDot;
case CEF_CUS_DASH:
return ui::ImeTextSpan::UnderlineStyle::kDash;
case CEF_CUS_NONE:
return ui::ImeTextSpan::UnderlineStyle::kNone;
}
NOTREACHED();
return ui::ImeTextSpan::UnderlineStyle::kSolid;
}
} // namespace
CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
@ -450,11 +461,6 @@ void CefRenderWidgetHostViewOSR::TakeFallbackContentFrom(
host()->GetContentRenderingTimeoutFrom(view_cef->host());
}
void CefRenderWidgetHostViewOSR::DidCreateNewRendererCompositorFrameSink(
viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink) {
NOTREACHED();
}
void CefRenderWidgetHostViewOSR::OnPresentCompositorFrame() {}
void CefRenderWidgetHostViewOSR::OnDidUpdateVisualPropertiesComplete(
@ -526,13 +532,6 @@ void CefRenderWidgetHostViewOSR::AddDamageRect(uint32_t sequence,
damage_rects_[sequence] = rect;
}
void CefRenderWidgetHostViewOSR::SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
viz::CompositorFrame frame,
base::Optional<viz::HitTestRegionList> hit_test_region_list) {
NOTREACHED();
}
void CefRenderWidgetHostViewOSR::ResetFallbackToFirstNavigationSurface() {
delegated_frame_host_->ResetFallbackToFirstNavigationSurface();
}
@ -795,7 +794,8 @@ void CefRenderWidgetHostViewOSR::ImeSetComposition(
ui::ImeTextSpan::Type::kComposition, line.range.from, line.range.to,
line.thick ? ui::ImeTextSpan::Thickness::kThick
: ui::ImeTextSpan::Thickness::kThin,
line.background_color, line.color, std::vector<std::string>()));
GetImeUnderlineStyle(line.style), line.background_color, line.color,
std::vector<std::string>()));
}
gfx::Range range(replacement_range.from, replacement_range.to);
@ -898,20 +898,6 @@ CefRenderWidgetHostViewOSR::CreateSyntheticGestureTarget() {
return std::make_unique<CefSyntheticGestureTargetOSR>(host());
}
void CefRenderWidgetHostViewOSR::SetNeedsBeginFrames(bool enabled) {
SetFrameRate();
if (host_display_client_) {
host_display_client_->SetActive(enabled);
}
}
void CefRenderWidgetHostViewOSR::SetWantsAnimateOnlyBeginFrames() {
if (delegated_frame_host_) {
delegated_frame_host_->SetWantsAnimateOnlyBeginFrames();
}
}
bool CefRenderWidgetHostViewOSR::TransformPointToCoordSpaceForView(
const gfx::PointF& point,
RenderWidgetHostViewBase* target_view,
@ -1108,13 +1094,15 @@ void CefRenderWidgetHostViewOSR::SendMouseEvent(
if (popup_host_view_) {
if (popup_host_view_->popup_position_.Contains(
event.PositionInWidget().x, event.PositionInWidget().y)) {
event.PositionInWidget().x(), event.PositionInWidget().y())) {
blink::WebMouseEvent popup_event(event);
popup_event.SetPositionInWidget(
event.PositionInWidget().x - popup_host_view_->popup_position_.x(),
event.PositionInWidget().y - popup_host_view_->popup_position_.y());
popup_event.SetPositionInScreen(popup_event.PositionInWidget().x,
popup_event.PositionInWidget().y);
event.PositionInWidget().x() -
popup_host_view_->popup_position_.x(),
event.PositionInWidget().y() -
popup_host_view_->popup_position_.y());
popup_event.SetPositionInScreen(popup_event.PositionInWidget().x(),
popup_event.PositionInWidget().y());
popup_host_view_->SendMouseEvent(popup_event);
return;
@ -1127,14 +1115,14 @@ void CefRenderWidgetHostViewOSR::SendMouseEvent(
}
const gfx::Rect& guest_bounds =
guest_host_view->render_widget_host_->GetView()->GetViewBounds();
if (guest_bounds.Contains(event.PositionInWidget().x,
event.PositionInWidget().y)) {
if (guest_bounds.Contains(event.PositionInWidget().x(),
event.PositionInWidget().y())) {
blink::WebMouseEvent guest_event(event);
guest_event.SetPositionInWidget(
event.PositionInWidget().x - guest_bounds.x(),
event.PositionInWidget().y - guest_bounds.y());
guest_event.SetPositionInScreen(guest_event.PositionInWidget().x,
guest_event.PositionInWidget().y);
event.PositionInWidget().x() - guest_bounds.x(),
event.PositionInWidget().y() - guest_bounds.y());
guest_event.SetPositionInScreen(guest_event.PositionInWidget().x(),
guest_event.PositionInWidget().y());
guest_host_view->SendMouseEvent(guest_event);
return;
@ -1168,14 +1156,16 @@ void CefRenderWidgetHostViewOSR::SendMouseWheelEvent(
if (popup_host_view_) {
if (popup_host_view_->popup_position_.Contains(
event.PositionInWidget().x, event.PositionInWidget().y)) {
event.PositionInWidget().x(), event.PositionInWidget().y())) {
blink::WebMouseWheelEvent popup_mouse_wheel_event(event);
popup_mouse_wheel_event.SetPositionInWidget(
event.PositionInWidget().x - popup_host_view_->popup_position_.x(),
event.PositionInWidget().y - popup_host_view_->popup_position_.y());
event.PositionInWidget().x() -
popup_host_view_->popup_position_.x(),
event.PositionInWidget().y() -
popup_host_view_->popup_position_.y());
popup_mouse_wheel_event.SetPositionInScreen(
popup_mouse_wheel_event.PositionInWidget().x,
popup_mouse_wheel_event.PositionInWidget().y);
popup_mouse_wheel_event.PositionInWidget().x(),
popup_mouse_wheel_event.PositionInWidget().y());
popup_host_view_->SendMouseWheelEvent(popup_mouse_wheel_event);
return;
@ -1196,15 +1186,15 @@ void CefRenderWidgetHostViewOSR::SendMouseWheelEvent(
}
const gfx::Rect& guest_bounds =
guest_host_view->render_widget_host_->GetView()->GetViewBounds();
if (guest_bounds.Contains(event.PositionInWidget().x,
event.PositionInWidget().y)) {
if (guest_bounds.Contains(event.PositionInWidget().x(),
event.PositionInWidget().y())) {
blink::WebMouseWheelEvent guest_mouse_wheel_event(event);
guest_mouse_wheel_event.SetPositionInWidget(
event.PositionInWidget().x - guest_bounds.x(),
event.PositionInWidget().y - guest_bounds.y());
event.PositionInWidget().x() - guest_bounds.x(),
event.PositionInWidget().y() - guest_bounds.y());
guest_mouse_wheel_event.SetPositionInScreen(
guest_mouse_wheel_event.PositionInWidget().x,
guest_mouse_wheel_event.PositionInWidget().y);
guest_mouse_wheel_event.PositionInWidget().x(),
guest_mouse_wheel_event.PositionInWidget().y());
guest_host_view->SendMouseWheelEvent(guest_mouse_wheel_event);
return;

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

@ -135,13 +135,6 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
#endif // defined(OS_MACOSX)
// RenderWidgetHostViewBase implementation.
void DidCreateNewRendererCompositorFrameSink(
viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink)
override;
void SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
viz::CompositorFrame frame,
base::Optional<viz::HitTestRegionList> hit_test_region_list) override;
void ResetFallbackToFirstNavigationSurface() override;
void InitAsPopup(content::RenderWidgetHostView* parent_host_view,
const gfx::Rect& pos) override;
@ -176,8 +169,6 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
const std::vector<gfx::Rect>& character_bounds) override;
std::unique_ptr<content::SyntheticGestureTarget>
CreateSyntheticGestureTarget() override;
void SetNeedsBeginFrames(bool enabled) override;
void SetWantsAnimateOnlyBeginFrames() override;
bool TransformPointToCoordSpaceForView(
const gfx::PointF& point,
RenderWidgetHostViewBase* target_view,
@ -400,9 +391,6 @@ class CefRenderWidgetHostViewOSR : public content::RenderWidgetHostViewBase,
content::MouseWheelPhaseHandler mouse_wheel_phase_handler_;
std::unique_ptr<viz::mojom::CompositorFrameSinkClient>
renderer_compositor_frame_sink_;
// Latest capture sequence number which is incremented when the caller
// requests surfaces be synchronized via
// EnsureSurfaceSynchronizedForLayoutTest().

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

@ -56,7 +56,7 @@
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/ui_base_switches.h"
#if defined(OS_MACOSX) || defined(OS_WIN)
#if 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) || defined(OS_WIN)
#if defined(OS_WIN)
OSCrypt::RegisterLocalPrefs(registry.get());
#endif
}

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

@ -290,8 +290,11 @@ void CefPrintViewManager::OnRequestPrintPreview_PrintToPdf(
DCHECK_EQ(pdf_print_state_->printing_rfh_, rfh);
rfh->Send(new PrintMsg_PrintPreview(rfh->GetRoutingID(),
pdf_print_state_->settings_));
mojo::AssociatedRemote<printing::mojom::PrintRenderFrame>
print_render_frame_remote;
rfh->GetRemoteAssociatedInterfaces()->GetInterface(
&print_render_frame_remote);
print_render_frame_remote->PrintPreview(pdf_print_state_->settings_.Clone());
}
void CefPrintViewManager::OnMetafileReadyForPrinting_PrintToPdf(

7
libcef/browser/server_impl.cc
View File

@ -381,7 +381,7 @@ void CefServerImpl::SendHttp200ResponseInternal(
if (!CEF_CURRENTLY_ON_HT()) {
CEF_POST_TASK_HT(base::BindOnce(&CefServerImpl::SendHttp200ResponseInternal,
this, connection_id, content_type,
base::Passed(std::move(data))));
std::move(data)));
return;
}
@ -407,8 +407,7 @@ void CefServerImpl::SendRawDataInternal(int connection_id,
std::unique_ptr<std::string> data) {
if (!CEF_CURRENTLY_ON_HT()) {
CEF_POST_TASK_HT(base::BindOnce(&CefServerImpl::SendRawDataInternal, this,
connection_id,
base::Passed(std::move(data))));
connection_id, std::move(data)));
return;
}
@ -427,7 +426,7 @@ void CefServerImpl::SendWebSocketMessageInternal(
if (!CEF_CURRENTLY_ON_HT()) {
CEF_POST_TASK_HT(
base::BindOnce(&CefServerImpl::SendWebSocketMessageInternal, this,
connection_id, base::Passed(std::move(data))));
connection_id, std::move(data)));
return;
}

10
libcef/browser/ssl_host_state_delegate.cc
View File

@ -57,7 +57,8 @@ bool CefSSLHostStateDelegate::DidHostRunInsecureContent(
void CefSSLHostStateDelegate::AllowCert(const std::string& host,
const net::X509Certificate& cert,
int error) {
int error,
content::WebContents* web_contents) {
cert_policy_for_host_[host].Allow(cert, error);
}
@ -82,7 +83,8 @@ void CefSSLHostStateDelegate::Clear(
SSLHostStateDelegate::CertJudgment CefSSLHostStateDelegate::QueryPolicy(
const std::string& host,
const net::X509Certificate& cert,
int error) {
int error,
content::WebContents* web_contents) {
return cert_policy_for_host_[host].Check(cert, error)
? SSLHostStateDelegate::ALLOWED
: SSLHostStateDelegate::DENIED;
@ -93,7 +95,9 @@ void CefSSLHostStateDelegate::RevokeUserAllowExceptions(
cert_policy_for_host_.erase(host);
}
bool CefSSLHostStateDelegate::HasAllowException(const std::string& host) {
bool CefSSLHostStateDelegate::HasAllowException(
const std::string& host,
content::WebContents* web_contents) {
auto policy_iterator = cert_policy_for_host_.find(host);
return policy_iterator != cert_policy_for_host_.end() &&
policy_iterator->second.HasAllowException();

9
libcef/browser/ssl_host_state_delegate.h
View File

@ -49,13 +49,15 @@ class CefSSLHostStateDelegate : public content::SSLHostStateDelegate {
// SSLHostStateDelegate methods:
void AllowCert(const std::string& host,
const net::X509Certificate& cert,
int error) override;
int error,
content::WebContents* web_contents) 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,
int error) override;
int error,
content::WebContents* web_contents) override;
void HostRanInsecureContent(const std::string& host,
int child_id,
InsecureContentType content_type) override;
@ -63,7 +65,8 @@ class CefSSLHostStateDelegate : public content::SSLHostStateDelegate {
int child_id,
InsecureContentType content_type) override;
void RevokeUserAllowExceptions(const std::string& host) override;
bool HasAllowException(const std::string& host) override;
bool HasAllowException(const std::string& host,
content::WebContents* web_contents) override;
private:
// Certificate policies for each host.

6
libcef/browser/x509_certificate_impl.cc
View File

@ -101,12 +101,12 @@ size_t CefX509CertificateImpl::GetIssuerChainSize() {
}
void CefX509CertificateImpl::AcquirePrivateKey(
const base::Callback<void(scoped_refptr<net::SSLPrivateKey>)>&
base::OnceCallback<void(scoped_refptr<net::SSLPrivateKey>)>
private_key_callback) {
if (identity_)
identity_->AcquirePrivateKey(private_key_callback);
identity_->AcquirePrivateKey(std::move(private_key_callback));
else
private_key_callback.Run(nullptr);
std::move(private_key_callback).Run(nullptr);
}
void CefX509CertificateImpl::GetEncodedIssuerChain(

2
libcef/browser/x509_certificate_impl.h
View File

@ -35,7 +35,7 @@ class CefX509CertificateImpl : public CefX509Certificate {
scoped_refptr<net::X509Certificate> GetInternalCertObject() { return cert_; }
void AcquirePrivateKey(
const base::Callback<void(scoped_refptr<net::SSLPrivateKey>)>&
base::OnceCallback<void(scoped_refptr<net::SSLPrivateKey>)>
private_key_callback);
private:

2
libcef/common/cef_messages.h
View File

@ -114,7 +114,7 @@ IPC_STRUCT_BEGIN(CefMsg_LoadRequest_Params)
// lead to undesired cookie blocking. Third-party cookie blocking can be
// bypassed by setting site_for_cookies = url, but this should ideally
// only be done if there really is no way to determine the correct value.
IPC_STRUCT_MEMBER(GURL, site_for_cookies)
IPC_STRUCT_MEMBER(net::SiteForCookies, site_for_cookies)
// Additional HTTP request headers.
IPC_STRUCT_MEMBER(std::string, headers)

1
libcef/common/main_delegate.cc
View File

@ -23,6 +23,7 @@
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"

11
libcef/common/net_service/net_service_util.cc
View File

@ -21,7 +21,6 @@
#include "net/url_request/redirect_util.h"
#include "net/url_request/url_request.h"
#include "services/network/public/cpp/resource_request.h"
#include "services/network/public/cpp/resource_response.h"
namespace net_service {
@ -91,7 +90,7 @@ std::string MakeContentTypeValue(const std::string& mime_type,
return value;
}
net::HttpResponseHeaders* MakeResponseHeaders(
scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
int status_code,
const std::string& status_text,
const std::string& mime_type,
@ -102,8 +101,8 @@ net::HttpResponseHeaders* MakeResponseHeaders(
if (status_code <= 0)
status_code = 200;
auto headers = new net::HttpResponseHeaders(
MakeStatusLine(status_code, status_text, false));
auto headers = WrapRefCounted(new net::HttpResponseHeaders(
MakeStatusLine(status_code, status_text, false)));
// Track the headers that have already been set. Perform all comparisons in
// lowercase.
@ -171,8 +170,8 @@ net::RedirectInfo MakeRedirectInfo(const network::ResourceRequest& request,
: net::URLRequest::NEVER_CHANGE_FIRST_PARTY_URL;
return net::RedirectInfo::ComputeRedirectInfo(
request.method, request.url, request.site_for_cookies,
first_party_url_policy, request.referrer_policy,
request.referrer.spec(), status_code, location,
first_party_url_policy, request.referrer_policy, request.referrer.spec(),
status_code, location,
net::RedirectUtil::GetReferrerPolicyHeader(headers),
insecure_scheme_was_upgraded);
}

5
libcef/common/net_service/net_service_util.h
View File

@ -10,6 +10,8 @@
#include "include/internal/cef_types_wrappers.h"
#include "base/memory/scoped_refptr.h"
namespace net {
class CanonicalCookie;
class HttpResponseHeaders;
@ -18,7 +20,6 @@ struct RedirectInfo;
namespace network {
struct ResourceRequest;
struct ResourceResponseHead;
} // namespace network
class GURL;
@ -48,7 +49,7 @@ std::string MakeContentTypeValue(const std::string& mime_type,
const std::string& charset);
// Make a new HttpResponseHeaders object.
net::HttpResponseHeaders* MakeResponseHeaders(
scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
int status_code,
const std::string& status_text,
const std::string& mime_type,

3
libcef/common/parser_impl.cc
View File

@ -102,8 +102,7 @@ CefString CefBase64Encode(const void* data, size_t data_size) {
if (data_size == 0)
return CefString();
base::StringPiece input;
input.set(static_cast<const char*>(data), data_size);
base::StringPiece input(static_cast<const char*>(data), data_size);
std::string output;
base::Base64Encode(input, &output);
return output;

104
libcef/common/request_impl.cc
View File

@ -299,13 +299,17 @@ void CefRequestImpl::SetReferrer(const CefString& referrer_url,
base::AutoLock lock_scope(lock_);
CHECK_READONLY_RETURN_VOID();
// Call GetAsReferrer here for consistency since the same logic will later be
// applied by URLRequest::SetReferrer().
const GURL& new_referrer_url = GURL(referrer_url.ToString()).GetAsReferrer();
if (referrer_url_ != new_referrer_url || referrer_policy_ != policy) {
const auto& sanitized_referrer = content::Referrer::SanitizeForRequest(
url_, content::Referrer(GURL(referrer_url.ToString()),
NetReferrerPolicyToBlinkReferrerPolicy(policy)));
const auto sanitized_policy =
BlinkReferrerPolicyToNetReferrerPolicy(sanitized_referrer.policy);
if (referrer_url_ != sanitized_referrer.url ||
referrer_policy_ != sanitized_policy) {
Changed(kChangedReferrer);
referrer_url_ = new_referrer_url;
referrer_policy_ = policy;
referrer_url_ = sanitized_referrer.url;
referrer_policy_ = sanitized_policy;
}
}
@ -425,16 +429,16 @@ void CefRequestImpl::SetFlags(int flags) {
CefString CefRequestImpl::GetFirstPartyForCookies() {
base::AutoLock lock_scope(lock_);
return first_party_for_cookies_.spec();
return site_for_cookies_.RepresentativeUrl().spec();
}
void CefRequestImpl::SetFirstPartyForCookies(const CefString& url) {
base::AutoLock lock_scope(lock_);
CHECK_READONLY_RETURN_VOID();
const GURL& new_url = GURL(url.ToString());
if (first_party_for_cookies_ != new_url) {
Changed(kChangedFirstPartyForCookies);
first_party_for_cookies_ = new_url;
auto new_site = net::SiteForCookies::FromUrl(GURL(url.ToString()));
if (!new_site.IsEquivalent(site_for_cookies_)) {
Changed(kChangedSiteForCookies);
site_for_cookies_ = new_site;
}
}
@ -464,12 +468,16 @@ void CefRequestImpl::Set(const network::ResourceRequest* request,
method_ = request->method;
identifier_ = identifier;
// Our consumer should have made sure that this is a safe referrer. See for
// instance WebCore::FrameLoader::HideReferrer.
if (request->referrer.is_valid()) {
referrer_url_ = request->referrer;
const auto& sanitized_referrer = content::Referrer::SanitizeForRequest(
request->url,
content::Referrer(
request->referrer,
NetReferrerPolicyToBlinkReferrerPolicy(
static_cast<cef_referrer_policy_t>(request->referrer_policy))));
referrer_url_ = sanitized_referrer.url;
referrer_policy_ =
static_cast<cef_referrer_policy_t>(request->referrer_policy);
BlinkReferrerPolicyToNetReferrerPolicy(sanitized_referrer.policy);
}
// Transfer request headers.
@ -481,7 +489,7 @@ void CefRequestImpl::Set(const network::ResourceRequest* request,
static_cast<CefPostDataImpl*>(postdata_.get())->Set(*request->request_body);
}
first_party_for_cookies_ = request->site_for_cookies;
site_for_cookies_ = request->site_for_cookies;
resource_type_ = static_cast<cef_resource_type_t>(request->resource_type);
transition_type_ =
@ -519,9 +527,9 @@ void CefRequestImpl::Get(network::ResourceRequest* request,
}
}
if (!first_party_for_cookies_.is_empty() &&
ShouldSet(kChangedFirstPartyForCookies, changed_only)) {
request->site_for_cookies = first_party_for_cookies_;
if (!site_for_cookies_.IsNull() &&
ShouldSet(kChangedSiteForCookies, changed_only)) {
request->site_for_cookies = site_for_cookies_;
}
if (ShouldSet(kChangedFlags, changed_only)) {
@ -560,10 +568,17 @@ void CefRequestImpl::Set(const net::RedirectInfo& redirect_info) {
url_ = redirect_info.new_url;
method_ = redirect_info.new_method;
first_party_for_cookies_ = redirect_info.new_site_for_cookies;
referrer_url_ = GURL(redirect_info.new_referrer);
site_for_cookies_ = redirect_info.new_site_for_cookies;
const auto& sanitized_referrer = content::Referrer::SanitizeForRequest(
redirect_info.new_url,
content::Referrer(GURL(redirect_info.new_referrer),
NetReferrerPolicyToBlinkReferrerPolicy(
static_cast<cef_referrer_policy_t>(
redirect_info.new_referrer_policy))));
referrer_url_ = sanitized_referrer.url;
referrer_policy_ =
static_cast<cef_referrer_policy_t>(redirect_info.new_referrer_policy);
BlinkReferrerPolicyToNetReferrerPolicy(sanitized_referrer.policy);
}
void CefRequestImpl::Set(const net::HttpRequestHeaders& headers) {
@ -584,7 +599,7 @@ void CefRequestImpl::Set(
url_ = params.url();
method_ = params.is_post() ? "POST" : "GET";
const content::Referrer& sanitized_referrer =
const auto& sanitized_referrer =
content::Referrer::SanitizeForRequest(params.url(), params.referrer());
referrer_url_ = sanitized_referrer.url;
referrer_policy_ =
@ -609,8 +624,9 @@ void CefRequestImpl::Get(blink::WebURLRequest& request,
NetReferrerPolicyToBlinkReferrerPolicy(referrer_policy_), url_,
blink::WebString::FromUTF8(referrer_url_.spec()));
if (!referrer.IsEmpty()) {
request.SetHttpReferrer(
referrer, NetReferrerPolicyToBlinkReferrerPolicy(referrer_policy_));
request.SetReferrerString(referrer);
request.SetReferrerPolicy(
NetReferrerPolicyToBlinkReferrerPolicy(referrer_policy_));
}
}
@ -634,8 +650,8 @@ void CefRequestImpl::Get(blink::WebURLRequest& request,
::SetHeaderMap(headermap_, request);
if (!first_party_for_cookies_.is_empty())
request.SetSiteForCookies(first_party_for_cookies_);
if (!site_for_cookies_.IsNull())
request.SetSiteForCookies(site_for_cookies_);
int flags = flags_;
if (!(flags & kURCachePolicyMask)) {
@ -666,10 +682,9 @@ void CefRequestImpl::Get(const CefMsg_LoadRequest_Params& params,
static_cast<cef_referrer_policy_t>(params.referrer_policy)),
params.url, blink::WebString::FromUTF8(params.referrer.spec()));
if (!referrer.IsEmpty()) {
request.SetHttpReferrer(
referrer,
NetReferrerPolicyToBlinkReferrerPolicy(
static_cast<cef_referrer_policy_t>(params.referrer_policy)));
request.SetReferrerString(referrer);
request.SetReferrerPolicy(NetReferrerPolicyToBlinkReferrerPolicy(
static_cast<cef_referrer_policy_t>(params.referrer_policy)));
}
}
@ -711,8 +726,10 @@ void CefRequestImpl::Get(const CefMsg_LoadRequest_Params& params,
data.Assign(element->bytes(), element->bytes_length());
body.AppendData(data);
} else if (element->type() == net::UploadElement::TYPE_FILE) {
body.AppendFile(
FilePathStringToWebString(element->file_path().value()));
body.AppendFileRange(
FilePathStringToWebString(element->file_path().value()),
element->file_range_offset(), element->file_range_length(),
element->expected_file_modification_time());
} else {
NOTREACHED();
}
@ -721,7 +738,7 @@ void CefRequestImpl::Get(const CefMsg_LoadRequest_Params& params,
request.SetHttpBody(body);
}
if (params.site_for_cookies.is_valid())
if (!params.site_for_cookies.IsNull())
request.SetSiteForCookies(params.site_for_cookies);
int flags = params.load_flags;
@ -758,7 +775,7 @@ void CefRequestImpl::Get(CefNavigateParams& params) const {
impl->Get(*params.upload_data.get());
}
params.site_for_cookies = first_party_for_cookies_;
params.site_for_cookies = site_for_cookies_;
params.load_flags = flags_;
}
@ -817,8 +834,8 @@ void CefRequestImpl::RevertChanges() {
}
if (backup_->backups_ & kChangedFlags)
flags_ = backup_->flags_;
if (backup_->backups_ & kChangedFirstPartyForCookies)
first_party_for_cookies_ = backup_->first_party_for_cookies_;
if (backup_->backups_ & kChangedSiteForCookies)
site_for_cookies_ = backup_->site_for_cookies_;
backup_.reset();
}
@ -938,10 +955,10 @@ void CefRequestImpl::Changed(uint8_t changes) {
backup_->flags_ = flags_;
backup_->backups_ |= kChangedFlags;
}
if ((changes & kChangedFirstPartyForCookies) &&
!(backup_->backups_ & kChangedFirstPartyForCookies)) {
backup_->first_party_for_cookies_ = first_party_for_cookies_;
backup_->backups_ |= kChangedFirstPartyForCookies;
if ((changes & kChangedSiteForCookies) &&
!(backup_->backups_ & kChangedSiteForCookies)) {
backup_->site_for_cookies_ = site_for_cookies_;
backup_->backups_ |= kChangedSiteForCookies;
}
}
@ -988,7 +1005,7 @@ void CefRequestImpl::Reset() {
transition_type_ = TT_EXPLICIT;
identifier_ = 0U;
flags_ = UR_FLAG_NONE;
first_party_for_cookies_ = GURL();
site_for_cookies_ = net::SiteForCookies();
changes_ = kChangedNone;
}
@ -1193,7 +1210,8 @@ void CefPostDataImpl::Get(blink::WebHTTPBody& data) const {
if (element.type == blink::WebHTTPBody::Element::kTypeData) {
data.AppendData(element.data);
} else if (element.type == blink::WebHTTPBody::Element::kTypeFile) {
data.AppendFile(element.file_path);
data.AppendFileRange(element.file_path, element.file_start,
element.file_length, element.modification_time);
} else {
NOTREACHED();
}

7
libcef/common/request_impl.h
View File

@ -13,6 +13,7 @@
#include "include/cef_request.h"
#include "base/synchronization/lock.h"
#include "net/cookies/site_for_cookies.h"
#include "services/network/public/mojom/referrer_policy.mojom-shared.h"
#include "third_party/blink/public/platform/web_http_body.h"
#include "url/gurl.h"
@ -54,7 +55,7 @@ class CefRequestImpl : public CefRequest {
kChangedPostData = 1 << 3,
kChangedHeaderMap = 1 << 4,
kChangedFlags = 1 << 5,
kChangedFirstPartyForCookies = 1 << 6,
kChangedSiteForCookies = 1 << 6,
};
CefRequestImpl();
@ -162,7 +163,7 @@ class CefRequestImpl : public CefRequest {
// The below members are used by CefURLRequest.
int flags_;
GURL first_party_for_cookies_;
net::SiteForCookies site_for_cookies_;
// Stores backup of values for use with track changes.
struct Backup {
@ -176,7 +177,7 @@ class CefRequestImpl : public CefRequest {
CefRefPtr<CefPostData> postdata_;
std::unique_ptr<HeaderMap> headermap_;
int flags_;
GURL first_party_for_cookies_;
net::SiteForCookies site_for_cookies_;
};
std::unique_ptr<Backup> backup_;

2
libcef/common/response_impl.cc
View File

@ -155,7 +155,7 @@ void CefResponseImpl::SetHeaderMap(const HeaderMap& headerMap) {
header_map_ = headerMap;
}
net::HttpResponseHeaders* CefResponseImpl::GetResponseHeaders() {
scoped_refptr<net::HttpResponseHeaders> CefResponseImpl::GetResponseHeaders() {
base::AutoLock lock_scope(lock_);
std::string mime_type = mime_type_;

2
libcef/common/response_impl.h
View File

@ -44,7 +44,7 @@ class CefResponseImpl : public CefResponse {
CefString GetURL() override;
void SetURL(const CefString& url) override;
net::HttpResponseHeaders* GetResponseHeaders();
scoped_refptr<net::HttpResponseHeaders> GetResponseHeaders();
void SetResponseHeaders(const net::HttpResponseHeaders& headers);
void Set(const blink::WebURLResponse& response);

10
libcef/common/widevine_loader.cc
View File

@ -417,14 +417,14 @@ void LoadWidevineCdmInfoOnBlockingThread(
cef_cdm_registration_error_t result =
LoadWidevineCdmInfo(base_path, args.get(), &error_message);
if (result != CEF_CDM_REGISTRATION_ERROR_NONE) {
CEF_POST_TASK(CEF_UIT, base::Bind(DeliverWidevineCdmCallback, result,
error_message, callback));
CEF_POST_TASK(CEF_UIT, base::BindOnce(DeliverWidevineCdmCallback, result,
error_message, callback));
return;
}
// Continue execution on the UI thread.
CEF_POST_TASK(CEF_UIT, base::Bind(RegisterWidevineCdmOnUIThread,
base::Passed(std::move(args)), callback));
CEF_POST_TASK(CEF_UIT, base::BindOnce(RegisterWidevineCdmOnUIThread,
std::move(args), callback));
}
} // namespace
@ -446,7 +446,7 @@ void CefWidevineLoader::LoadWidevineCdm(
}
CEF_POST_USER_VISIBLE_TASK(
base::Bind(LoadWidevineCdmInfoOnBlockingThread, path, callback));
base::BindOnce(LoadWidevineCdmInfoOnBlockingThread, path, callback));
}
void CefWidevineLoader::OnContextInitialized() {

12
libcef/renderer/blink_glue.cc
View File

@ -61,8 +61,10 @@ void GoBack(blink::WebView* view) {
if (main_frame && main_frame->IsWebLocalFrame()) {
blink::WebViewImpl* view_impl = reinterpret_cast<blink::WebViewImpl*>(view);
if (view_impl->Client()->HistoryBackListCount() > 0) {
main_frame->ToWebLocalFrame()->Client()->NavigateBackForwardSoon(
-1, true /* has_user_gesture */);
blink::Frame* core_frame = blink::WebFrame::ToCoreFrame(*main_frame);
blink::To<blink::LocalFrame>(core_frame)
->GetLocalFrameHostRemote()
.GoToEntryAtOffset(-1, true /* has_user_gesture */);
}
}
}
@ -75,8 +77,10 @@ void GoForward(blink::WebView* view) {
if (main_frame && main_frame->IsWebLocalFrame()) {
blink::WebViewImpl* view_impl = reinterpret_cast<blink::WebViewImpl*>(view);
if (view_impl->Client()->HistoryForwardListCount() > 0) {
main_frame->ToWebLocalFrame()->Client()->NavigateBackForwardSoon(
1, true /* has_user_gesture */);
blink::Frame* core_frame = blink::WebFrame::ToCoreFrame(*main_frame);
blink::To<blink::LocalFrame>(core_frame)
->GetLocalFrameHostRemote()
.GoToEntryAtOffset(1, true /* has_user_gesture */);
}
}
}

10
libcef/renderer/content_renderer_client.cc
View File

@ -64,7 +64,6 @@
#include "components/printing/renderer/print_render_frame_helper.h"
#include "components/spellcheck/renderer/spellcheck.h"
#include "components/spellcheck/renderer/spellcheck_provider.h"
#include "components/startup_metric_utils/common/startup_metric.mojom.h"
#include "components/visitedlink/renderer/visitedlink_reader.h"
#include "components/web_cache/renderer/web_cache_impl.h"
#include "content/common/frame_messages.h"
@ -393,13 +392,6 @@ void CefContentRendererClient::RenderThreadStarted() {
? blink::scheduler::WebRendererProcessType::kExtensionRenderer
: blink::scheduler::WebRendererProcessType::kRenderer);
{
mojo::Remote<startup_metric_utils::mojom::StartupMetricHost>
startup_metric_host;
thread->BindHostReceiver(startup_metric_host.BindNewPipeAndPassReceiver());
startup_metric_host->RecordRendererMainEntryTime(main_entry_time_);
}
thread->AddObserver(observer_.get());
if (!command_line->HasSwitch(switches::kDisableSpellChecking)) {
@ -609,7 +601,7 @@ void CefContentRendererClient::WillSendRequest(
blink::WebLocalFrame* frame,
ui::PageTransition transition_type,
const blink::WebURL& url,
const blink::WebURL& site_for_cookies,
const net::SiteForCookies& site_for_cookies,
const url::Origin* initiator_origin,
GURL* new_url,
bool* attach_same_site_cookies) {

2
libcef/renderer/content_renderer_client.h
View File

@ -118,7 +118,7 @@ class CefContentRendererClient
void WillSendRequest(blink::WebLocalFrame* frame,
ui::PageTransition transition_type,
const blink::WebURL& url,
const blink::WebURL& site_for_cookies,
const net::SiteForCookies& site_for_cookies,
const url::Origin* initiator_origin,
GURL* new_url,
bool* attach_same_site_cookies) override;

2
libcef/renderer/extensions/extensions_renderer_client.cc
View File

@ -122,7 +122,7 @@ void CefExtensionsRendererClient::WillSendRequest(
blink::WebLocalFrame* frame,
ui::PageTransition transition_type,
const blink::WebURL& url,
const blink::WebURL& site_for_cookies,
const net::SiteForCookies& site_for_cookies,
const url::Origin* initiator_origin,
GURL* new_url,
bool* attach_same_site_cookies) {

6
libcef/renderer/extensions/extensions_renderer_client.h
View File

@ -22,6 +22,10 @@ struct WebPluginParams;
class WebURL;
} // namespace blink
namespace net {
class SiteForCookies;
}
namespace content {
class BrowserPluginDelegate;
class RenderFrame;
@ -64,7 +68,7 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
void WillSendRequest(blink::WebLocalFrame* frame,
ui::PageTransition transition_type,
const blink::WebURL& url,
const blink::WebURL& site_for_cookies,
const net::SiteForCookies& site_for_cookies,
const url::Origin* initiator_origin,
GURL* new_url,
bool* attach_same_site_cookies);

5
libcef/renderer/extensions/print_render_frame_helper_delegate.cc
View File

@ -29,11 +29,6 @@ CefPrintRenderFrameHelperDelegate::CefPrintRenderFrameHelperDelegate(
CefPrintRenderFrameHelperDelegate::~CefPrintRenderFrameHelperDelegate() {}
bool CefPrintRenderFrameHelperDelegate::CancelPrerender(
content::RenderFrame* render_frame) {
return false;
}
// Return the PDF object element if |frame| is the out of process PDF extension.
blink::WebElement CefPrintRenderFrameHelperDelegate::GetPdfElement(
blink::WebLocalFrame* frame) {

1
libcef/renderer/extensions/print_render_frame_helper_delegate.h
View File

@ -15,7 +15,6 @@ class CefPrintRenderFrameHelperDelegate
explicit CefPrintRenderFrameHelperDelegate(bool is_windowless);
~CefPrintRenderFrameHelperDelegate() override;
bool CancelPrerender(content::RenderFrame* render_frame) override;
blink::WebElement GetPdfElement(blink::WebLocalFrame* frame) override;
bool IsPrintPreviewEnabled() override;
bool OverridePrint(blink::WebLocalFrame* frame) override;

5
libcef/renderer/frame_impl.cc
View File

@ -120,8 +120,8 @@ void CefFrameImpl::LoadRequest(CefRefPtr<CefRequest> request) {
CefMsg_LoadRequest_Params params;
params.url = GURL(std::string(request->GetURL()));
params.method = request->GetMethod();
params.site_for_cookies =
GURL(std::string(request->GetFirstPartyForCookies()));
params.site_for_cookies = net::SiteForCookies::FromUrl(
GURL(request->GetFirstPartyForCookies().ToString()));
CefRequest::HeaderMap headerMap;
request->GetHeaderMap(headerMap);
@ -504,7 +504,6 @@ void CefFrameImpl::OnDidStopLoading() {
// in this frame's in-process subtree. If there are multiple of these for the
// same browser then the other occurrences will be discarded in
// OnLoadingStateChange.
DCHECK(frame_->IsLocalRoot());
browser_->OnLoadingStateChange(false);
}

4
libcef/renderer/render_urlrequest_impl.cc
View File

@ -56,7 +56,7 @@ class CefWebURLLoaderClient : public blink::WebURLLoaderClient {
void DidStartLoadingResponseBody(
mojo::ScopedDataPipeConsumerHandle response_body) override;
bool WillFollowRedirect(const WebURL& new_url,
const WebURL& new_site_for_cookies,
const net::SiteForCookies& new_site_for_cookies,
const WebString& new_referrer,
network::mojom::ReferrerPolicy new_referrer_policy,
const WebString& new_method,
@ -392,7 +392,7 @@ void CefWebURLLoaderClient::DidStartLoadingResponseBody(
bool CefWebURLLoaderClient::WillFollowRedirect(
const WebURL& new_url,
const WebURL& new_site_for_cookies,
const net::SiteForCookies& new_site_for_cookies,
const WebString& new_referrer,
network::mojom::ReferrerPolicy new_referrer_policy,
const WebString& new_method,