2012-04-03 03:34:16 +02:00
|
|
|
// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights
|
|
|
|
// reserved. Use of this source code is governed by a BSD-style license that can
|
|
|
|
// be found in the LICENSE file.
|
|
|
|
|
2017-05-19 11:06:00 +02:00
|
|
|
#include "libcef/browser/frame_host_impl.h"
|
2019-05-11 00:14:48 +02:00
|
|
|
|
2012-04-03 03:34:16 +02:00
|
|
|
#include "include/cef_request.h"
|
|
|
|
#include "include/cef_stream.h"
|
|
|
|
#include "include/cef_v8.h"
|
2017-05-31 17:33:30 +02:00
|
|
|
#include "include/test/cef_test_helpers.h"
|
2020-09-18 00:24:08 +02:00
|
|
|
#include "libcef/browser/browser_host_base.h"
|
2019-05-11 00:14:48 +02:00
|
|
|
#include "libcef/browser/net_service/browser_urlrequest_impl.h"
|
2021-05-14 18:58:55 +02:00
|
|
|
#include "libcef/common/frame_util.h"
|
2021-04-15 01:28:22 +02:00
|
|
|
#include "libcef/common/net/url_util.h"
|
2019-05-24 22:23:43 +02:00
|
|
|
#include "libcef/common/process_message_impl.h"
|
|
|
|
#include "libcef/common/request_impl.h"
|
2021-05-14 18:58:55 +02:00
|
|
|
#include "libcef/common/string_util.h"
|
2019-05-11 00:14:48 +02:00
|
|
|
#include "libcef/common/task_runner_impl.h"
|
|
|
|
|
2020-10-08 21:54:42 +02:00
|
|
|
#include "content/browser/renderer_host/frame_tree_node.h"
|
2019-05-11 00:14:48 +02:00
|
|
|
#include "content/public/browser/render_process_host.h"
|
|
|
|
#include "content/public/browser/render_view_host.h"
|
2021-05-14 18:58:55 +02:00
|
|
|
#include "services/service_manager/public/cpp/interface_provider.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void StringVisitCallback(CefRefPtr<CefStringVisitor> visitor,
|
|
|
|
base::ReadOnlySharedMemoryRegion response) {
|
|
|
|
string_util::ExecuteWithScopedCefString(
|
|
|
|
std::move(response),
|
|
|
|
base::BindOnce([](CefRefPtr<CefStringVisitor> visitor,
|
|
|
|
const CefString& str) { visitor->Visit(str); },
|
|
|
|
visitor));
|
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void ViewTextCallback(CefRefPtr<CefFrameHostImpl> frame,
|
|
|
|
base::ReadOnlySharedMemoryRegion response) {
|
|
|
|
if (auto browser = frame->GetBrowser()) {
|
|
|
|
string_util::ExecuteWithScopedCefString(
|
|
|
|
std::move(response),
|
|
|
|
base::BindOnce(
|
|
|
|
[](CefRefPtr<CefBrowser> browser, const CefString& str) {
|
|
|
|
static_cast<CefBrowserHostBase*>(browser.get())->ViewText(str);
|
|
|
|
},
|
|
|
|
browser));
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
2021-05-14 18:58:55 +02:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
CefFrameHostImpl::CefFrameHostImpl(scoped_refptr<CefBrowserInfo> browser_info,
|
|
|
|
int64_t parent_frame_id)
|
2021-05-21 03:42:58 +02:00
|
|
|
: is_main_frame_(false),
|
2019-05-24 22:23:43 +02:00
|
|
|
frame_id_(kInvalidFrameId),
|
|
|
|
browser_info_(browser_info),
|
2014-09-24 17:38:11 +02:00
|
|
|
is_focused_(is_main_frame_), // The main frame always starts focused.
|
2019-05-24 22:23:43 +02:00
|
|
|
parent_frame_id_(parent_frame_id) {
|
|
|
|
#if DCHECK_IS_ON()
|
|
|
|
DCHECK(browser_info_);
|
|
|
|
if (is_main_frame_) {
|
|
|
|
DCHECK_EQ(parent_frame_id_, kInvalidFrameId);
|
|
|
|
} else {
|
|
|
|
DCHECK_GT(parent_frame_id_, 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
CefFrameHostImpl::CefFrameHostImpl(scoped_refptr<CefBrowserInfo> browser_info,
|
|
|
|
content::RenderFrameHost* render_frame_host)
|
|
|
|
: is_main_frame_(render_frame_host->GetParent() == nullptr),
|
2021-05-21 03:42:58 +02:00
|
|
|
frame_id_(MakeFrameId(render_frame_host)),
|
2019-05-24 22:23:43 +02:00
|
|
|
browser_info_(browser_info),
|
|
|
|
is_focused_(is_main_frame_), // The main frame always starts focused.
|
2021-05-21 03:42:58 +02:00
|
|
|
url_(render_frame_host->GetLastCommittedURL().spec()),
|
|
|
|
name_(render_frame_host->GetFrameName()),
|
2019-05-24 22:23:43 +02:00
|
|
|
parent_frame_id_(is_main_frame_
|
2017-05-17 11:29:28 +02:00
|
|
|
? kInvalidFrameId
|
2021-05-21 03:42:58 +02:00
|
|
|
: MakeFrameId(render_frame_host->GetParent())),
|
|
|
|
render_frame_host_(render_frame_host) {
|
2019-05-24 22:23:43 +02:00
|
|
|
DCHECK(browser_info_);
|
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
CefFrameHostImpl::~CefFrameHostImpl() {
|
|
|
|
// Should have been Detached.
|
|
|
|
DCHECK(!browser_info_);
|
|
|
|
DCHECK(!render_frame_host_);
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool CefFrameHostImpl::IsValid() {
|
2020-09-18 00:24:08 +02:00
|
|
|
return !!GetBrowserHostBase();
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Undo() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Undo");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Redo() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Redo");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Cut() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Cut");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Copy() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Copy");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Paste() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Paste");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::Delete() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("Delete");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::SelectAll() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommand("SelectAll");
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::ViewSource() {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommandWithResponse(
|
|
|
|
"GetSource",
|
|
|
|
base::BindOnce(&ViewTextCallback, CefRefPtr<CefFrameHostImpl>(this)));
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::GetSource(CefRefPtr<CefStringVisitor> visitor) {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommandWithResponse("GetSource",
|
|
|
|
base::BindOnce(&StringVisitCallback, visitor));
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::GetText(CefRefPtr<CefStringVisitor> visitor) {
|
2021-05-14 18:58:55 +02:00
|
|
|
SendCommandWithResponse("GetText",
|
|
|
|
base::BindOnce(&StringVisitCallback, visitor));
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::LoadRequest(CefRefPtr<CefRequest> request) {
|
2021-05-14 18:58:55 +02:00
|
|
|
auto params = cef::mojom::RequestParams::New();
|
2019-05-24 22:23:43 +02:00
|
|
|
static_cast<CefRequestImpl*>(request.get())->Get(params);
|
2021-05-14 18:58:55 +02:00
|
|
|
LoadRequest(std::move(params));
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::LoadURL(const CefString& url) {
|
2020-02-14 22:58:58 +01:00
|
|
|
LoadURLWithExtras(url, content::Referrer(), kPageTransitionExplicit,
|
2019-05-24 22:23:43 +02:00
|
|
|
std::string());
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::ExecuteJavaScript(const CefString& jsCode,
|
|
|
|
const CefString& scriptUrl,
|
|
|
|
int startLine) {
|
2012-10-18 00:45:49 +02:00
|
|
|
SendJavaScript(jsCode, scriptUrl, startLine);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool CefFrameHostImpl::IsMain() {
|
|
|
|
return is_main_frame_;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CefFrameHostImpl::IsFocused() {
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
return is_focused_;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefString CefFrameHostImpl::GetName() {
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
return name_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64 CefFrameHostImpl::GetIdentifier() {
|
2019-05-24 22:23:43 +02:00
|
|
|
base::AutoLock lock_scope(state_lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return frame_id_;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefFrame> CefFrameHostImpl::GetParent() {
|
2013-05-31 17:34:53 +02:00
|
|
|
int64 parent_frame_id;
|
|
|
|
|
|
|
|
{
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
if (is_main_frame_ || parent_frame_id_ == kInvalidFrameId)
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2013-05-31 17:34:53 +02:00
|
|
|
parent_frame_id = parent_frame_id_;
|
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2020-09-18 00:24:08 +02:00
|
|
|
auto browser = GetBrowserHostBase();
|
2019-05-24 22:23:43 +02:00
|
|
|
if (browser)
|
2013-05-31 17:34:53 +02:00
|
|
|
return browser->GetFrame(parent_frame_id);
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CefString CefFrameHostImpl::GetURL() {
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
return url_;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefBrowser> CefFrameHostImpl::GetBrowser() {
|
2020-09-18 00:24:08 +02:00
|
|
|
return GetBrowserHostBase().get();
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefV8Context> CefFrameHostImpl::GetV8Context() {
|
|
|
|
NOTREACHED() << "GetV8Context cannot be called from the browser process";
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
2012-04-27 23:19:06 +02:00
|
|
|
void CefFrameHostImpl::VisitDOM(CefRefPtr<CefDOMVisitor> visitor) {
|
|
|
|
NOTREACHED() << "VisitDOM cannot be called from the browser process";
|
|
|
|
}
|
|
|
|
|
2019-05-11 00:14:48 +02:00
|
|
|
CefRefPtr<CefURLRequest> CefFrameHostImpl::CreateURLRequest(
|
|
|
|
CefRefPtr<CefRequest> request,
|
|
|
|
CefRefPtr<CefURLRequestClient> client) {
|
|
|
|
if (!request || !client)
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2019-05-11 00:14:48 +02:00
|
|
|
|
|
|
|
if (!CefTaskRunnerImpl::GetCurrentTaskRunner()) {
|
|
|
|
NOTREACHED() << "called on invalid thread";
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2019-05-11 00:14:48 +02:00
|
|
|
}
|
|
|
|
|
2020-09-18 00:24:08 +02:00
|
|
|
auto browser = GetBrowserHostBase();
|
2019-05-11 00:14:48 +02:00
|
|
|
if (!browser)
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
2019-05-11 00:14:48 +02:00
|
|
|
|
|
|
|
auto request_context = browser->request_context();
|
|
|
|
|
2019-07-29 23:27:12 +02:00
|
|
|
CefRefPtr<CefBrowserURLRequest> impl =
|
|
|
|
new CefBrowserURLRequest(this, request, client, request_context);
|
|
|
|
if (impl->Start())
|
|
|
|
return impl.get();
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::SendProcessMessage(
|
|
|
|
CefProcessId target_process,
|
|
|
|
CefRefPtr<CefProcessMessage> message) {
|
|
|
|
DCHECK_EQ(PID_RENDERER, target_process);
|
2021-05-14 18:58:55 +02:00
|
|
|
DCHECK(message && message->IsValid());
|
|
|
|
if (!message || !message->IsValid())
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
|
|
|
|
2021-05-20 20:54:07 +02:00
|
|
|
// Invalidate the message object immediately by taking the argument list.
|
|
|
|
auto argument_list =
|
|
|
|
static_cast<CefProcessMessageImpl*>(message.get())->TakeArgumentList();
|
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(__FUNCTION__,
|
|
|
|
base::BindOnce(
|
|
|
|
[](const CefString& name, base::ListValue argument_list,
|
|
|
|
const RenderFrameType& render_frame) {
|
|
|
|
render_frame->SendMessage(name,
|
|
|
|
std::move(argument_list));
|
|
|
|
},
|
|
|
|
message->GetName(), std::move(argument_list)));
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::SetFocused(bool focused) {
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
is_focused_ = focused;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::RefreshAttributes() {
|
|
|
|
CEF_REQUIRE_UIT();
|
|
|
|
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
|
|
|
if (!render_frame_host_)
|
|
|
|
return;
|
|
|
|
url_ = render_frame_host_->GetLastCommittedURL().spec();
|
|
|
|
|
|
|
|
// Use the assigned name if it is non-empty. This represents the name property
|
|
|
|
// on the frame DOM element. If the assigned name is empty, revert to the
|
|
|
|
// internal unique name. This matches the logic in render_frame_util::GetName.
|
|
|
|
name_ = render_frame_host_->GetFrameName();
|
|
|
|
if (name_.empty()) {
|
|
|
|
const auto node = content::FrameTreeNode::GloballyFindByID(
|
|
|
|
render_frame_host_->GetFrameTreeNodeId());
|
|
|
|
if (node) {
|
|
|
|
name_ = node->unique_name();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_main_frame_)
|
|
|
|
parent_frame_id_ = MakeFrameId(render_frame_host_->GetParent());
|
|
|
|
}
|
|
|
|
|
2020-12-02 23:31:49 +01:00
|
|
|
void CefFrameHostImpl::NotifyMoveOrResizeStarted() {
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(__FUNCTION__,
|
|
|
|
base::BindOnce([](const RenderFrameType& render_frame) {
|
|
|
|
render_frame->MoveOrResizeStarted();
|
|
|
|
}));
|
2020-12-02 23:31:49 +01:00
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::LoadRequest(cef::mojom::RequestParamsPtr params) {
|
|
|
|
if (!url_util::FixupGURL(params->url))
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(__FUNCTION__,
|
|
|
|
base::BindOnce(
|
|
|
|
[](cef::mojom::RequestParamsPtr params,
|
|
|
|
const RenderFrameType& render_frame) {
|
|
|
|
render_frame->LoadRequest(std::move(params));
|
|
|
|
},
|
|
|
|
std::move(params)));
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2020-09-18 00:24:08 +02:00
|
|
|
auto browser = GetBrowserHostBase();
|
2019-05-24 22:23:43 +02:00
|
|
|
if (browser)
|
|
|
|
browser->OnSetFocus(FOCUS_SOURCE_NAVIGATION);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::LoadURLWithExtras(const std::string& url,
|
|
|
|
const content::Referrer& referrer,
|
|
|
|
ui::PageTransition transition,
|
|
|
|
const std::string& extra_headers) {
|
|
|
|
// Only known frame ids or kMainFrameId are supported.
|
|
|
|
const auto frame_id = GetFrameId();
|
|
|
|
if (frame_id < CefFrameHostImpl::kMainFrameId)
|
|
|
|
return;
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
// Any necessary fixup will occur in LoadRequest.
|
|
|
|
GURL gurl = url_util::MakeGURL(url, /*fixup=*/false);
|
2020-09-25 03:40:47 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
if (frame_id == CefFrameHostImpl::kMainFrameId) {
|
|
|
|
// Load via the browser using NavigationController.
|
2020-09-18 00:24:08 +02:00
|
|
|
auto browser = GetBrowserHostBase();
|
2019-05-24 22:23:43 +02:00
|
|
|
if (browser) {
|
2020-09-25 03:40:47 +02:00
|
|
|
content::OpenURLParams params(
|
|
|
|
gurl, referrer, WindowOpenDisposition::CURRENT_TAB, transition,
|
|
|
|
/*is_renderer_initiated=*/false);
|
|
|
|
params.extra_headers = extra_headers;
|
|
|
|
|
|
|
|
browser->LoadMainFrameURL(params);
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
} else {
|
2021-05-14 18:58:55 +02:00
|
|
|
auto params = cef::mojom::RequestParams::New();
|
|
|
|
params->url = gurl;
|
|
|
|
params->referrer =
|
|
|
|
blink::mojom::Referrer::New(referrer.url, referrer.policy);
|
|
|
|
params->headers = extra_headers;
|
|
|
|
LoadRequest(std::move(params));
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::SendCommand(const std::string& command) {
|
2019-05-24 22:23:43 +02:00
|
|
|
DCHECK(!command.empty());
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(__FUNCTION__, base::BindOnce(
|
|
|
|
[](const std::string& command,
|
|
|
|
const RenderFrameType& render_frame) {
|
|
|
|
render_frame->SendCommand(command);
|
|
|
|
},
|
|
|
|
command));
|
2019-05-11 00:14:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::SendCommandWithResponse(
|
|
|
|
const std::string& command,
|
|
|
|
cef::mojom::RenderFrame::SendCommandWithResponseCallback
|
|
|
|
response_callback) {
|
|
|
|
DCHECK(!command.empty());
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(
|
|
|
|
__FUNCTION__,
|
|
|
|
base::BindOnce(
|
|
|
|
[](const std::string& command,
|
|
|
|
cef::mojom::RenderFrame::SendCommandWithResponseCallback
|
|
|
|
response_callback,
|
|
|
|
const RenderFrameType& render_frame) {
|
|
|
|
render_frame->SendCommandWithResponse(command,
|
|
|
|
std::move(response_callback));
|
|
|
|
},
|
|
|
|
command, std::move(response_callback)));
|
2021-05-14 18:58:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefFrameHostImpl::SendJavaScript(const std::u16string& jsCode,
|
2017-05-17 11:29:28 +02:00
|
|
|
const std::string& scriptUrl,
|
|
|
|
int startLine) {
|
2012-10-18 00:45:49 +02:00
|
|
|
if (jsCode.empty())
|
|
|
|
return;
|
2016-10-17 20:14:44 +02:00
|
|
|
if (startLine <= 0) {
|
|
|
|
// A value of 0 is v8::Message::kNoLineNumberInfo in V8. There is code in
|
|
|
|
// V8 that will assert on that value (e.g. V8StackTraceImpl::Frame::Frame
|
|
|
|
// if a JS exception is thrown) so make sure |startLine| > 0.
|
|
|
|
startLine = 1;
|
|
|
|
}
|
2012-10-18 00:45:49 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(
|
|
|
|
__FUNCTION__,
|
|
|
|
base::BindOnce(
|
|
|
|
[](const std::u16string& jsCode, const std::string& scriptUrl,
|
|
|
|
int startLine, const RenderFrameType& render_frame) {
|
|
|
|
render_frame->SendJavaScript(jsCode, scriptUrl, startLine);
|
|
|
|
},
|
|
|
|
jsCode, scriptUrl, startLine));
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
2013-05-31 17:34:53 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
void CefFrameHostImpl::MaybeSendDidStopLoading() {
|
|
|
|
auto rfh = GetRenderFrameHost();
|
|
|
|
if (!rfh)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// We only want to notify for the highest-level LocalFrame in this frame's
|
|
|
|
// renderer process subtree. If this frame has a parent in the same process
|
|
|
|
// then the notification will be sent via the parent instead.
|
|
|
|
auto rfh_parent = rfh->GetParent();
|
|
|
|
if (rfh_parent && rfh_parent->GetProcess() == rfh->GetProcess()) {
|
|
|
|
return;
|
2012-10-18 00:45:49 +02:00
|
|
|
}
|
2013-05-31 17:34:53 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
SendToRenderFrame(__FUNCTION__,
|
|
|
|
base::BindOnce([](const RenderFrameType& render_frame) {
|
|
|
|
render_frame->DidStopLoading();
|
|
|
|
}));
|
2012-10-18 00:45:49 +02:00
|
|
|
}
|
|
|
|
|
2017-05-31 17:33:30 +02:00
|
|
|
void CefFrameHostImpl::ExecuteJavaScriptWithUserGestureForTests(
|
|
|
|
const CefString& javascript) {
|
2019-05-11 00:14:48 +02:00
|
|
|
if (!CEF_CURRENTLY_ON_UIT()) {
|
|
|
|
CEF_POST_TASK(
|
|
|
|
CEF_UIT,
|
|
|
|
base::BindOnce(
|
|
|
|
&CefFrameHostImpl::ExecuteJavaScriptWithUserGestureForTests, this,
|
|
|
|
javascript));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
content::RenderFrameHost* rfh = GetRenderFrameHost();
|
|
|
|
if (rfh)
|
|
|
|
rfh->ExecuteJavaScriptWithUserGestureForTests(javascript);
|
|
|
|
}
|
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
content::RenderFrameHost* CefFrameHostImpl::GetRenderFrameHost() const {
|
2019-05-11 00:14:48 +02:00
|
|
|
CEF_REQUIRE_UIT();
|
2019-05-24 22:23:43 +02:00
|
|
|
return render_frame_host_;
|
|
|
|
}
|
2019-05-11 00:14:48 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
void CefFrameHostImpl::Detach() {
|
|
|
|
CEF_REQUIRE_UIT();
|
2017-05-31 17:33:30 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
// Should not be called for temporary frames.
|
|
|
|
DCHECK(!is_temporary());
|
|
|
|
|
2017-05-31 17:33:30 +02:00
|
|
|
{
|
|
|
|
base::AutoLock lock_scope(state_lock_);
|
2021-05-21 03:42:58 +02:00
|
|
|
|
|
|
|
// Should be called only once.
|
|
|
|
DCHECK(browser_info_);
|
2019-05-24 22:23:43 +02:00
|
|
|
browser_info_ = nullptr;
|
2017-05-31 17:33:30 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
// In case we never attached, clean up.
|
2021-05-14 18:58:55 +02:00
|
|
|
while (!queued_actions_.empty()) {
|
|
|
|
queued_actions_.pop();
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
2019-05-11 00:14:48 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
render_frame_.reset();
|
2019-05-24 22:23:43 +02:00
|
|
|
render_frame_host_ = nullptr;
|
2021-05-21 03:42:58 +02:00
|
|
|
is_attached_ = false;
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
2019-05-11 00:14:48 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
// static
|
|
|
|
int64_t CefFrameHostImpl::MakeFrameId(const content::RenderFrameHost* host) {
|
|
|
|
CEF_REQUIRE_UIT();
|
|
|
|
auto host_nonconst = const_cast<content::RenderFrameHost*>(host);
|
|
|
|
return MakeFrameId(host_nonconst->GetProcess()->GetID(),
|
|
|
|
host_nonconst->GetRoutingID());
|
|
|
|
}
|
2019-05-11 00:14:48 +02:00
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
// static
|
|
|
|
int64_t CefFrameHostImpl::MakeFrameId(int32_t render_process_id,
|
|
|
|
int32_t render_routing_id) {
|
|
|
|
return frame_util::MakeFrameId(render_process_id, render_routing_id);
|
2017-05-31 17:33:30 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
// kMainFrameId must be -1 to align with renderer expectations.
|
|
|
|
const int64_t CefFrameHostImpl::kMainFrameId = -1;
|
|
|
|
const int64_t CefFrameHostImpl::kFocusedFrameId = -2;
|
|
|
|
const int64_t CefFrameHostImpl::kUnspecifiedFrameId = -3;
|
|
|
|
const int64_t CefFrameHostImpl::kInvalidFrameId = -4;
|
|
|
|
|
2020-02-14 22:58:58 +01:00
|
|
|
// This equates to (TT_EXPLICIT | TT_DIRECT_LOAD_FLAG).
|
|
|
|
const ui::PageTransition CefFrameHostImpl::kPageTransitionExplicit =
|
|
|
|
static_cast<ui::PageTransition>(ui::PAGE_TRANSITION_TYPED |
|
|
|
|
ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
|
|
|
|
|
2019-05-24 22:23:43 +02:00
|
|
|
int64 CefFrameHostImpl::GetFrameId() const {
|
2012-04-03 03:34:16 +02:00
|
|
|
base::AutoLock lock_scope(state_lock_);
|
2019-05-24 22:23:43 +02:00
|
|
|
return is_main_frame_ ? kMainFrameId : frame_id_;
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
2013-05-31 17:34:53 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
scoped_refptr<CefBrowserInfo> CefFrameHostImpl::GetBrowserInfo() const {
|
2019-05-24 22:23:43 +02:00
|
|
|
base::AutoLock lock_scope(state_lock_);
|
2021-05-21 03:42:58 +02:00
|
|
|
return browser_info_;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefBrowserHostBase> CefFrameHostImpl::GetBrowserHostBase() const {
|
|
|
|
if (auto browser_info = GetBrowserInfo())
|
|
|
|
return browser_info->browser();
|
2019-05-24 22:23:43 +02:00
|
|
|
return nullptr;
|
|
|
|
}
|
2013-05-31 17:34:53 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
const mojo::Remote<cef::mojom::RenderFrame>&
|
|
|
|
CefFrameHostImpl::GetRenderFrame() {
|
|
|
|
CEF_REQUIRE_UIT();
|
|
|
|
DCHECK(is_attached_);
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
if (!render_frame_.is_bound() && render_frame_host_ &&
|
|
|
|
render_frame_host_->GetRemoteInterfaces()) {
|
|
|
|
// Connects to a CefFrameImpl that already exists in the renderer process.
|
|
|
|
render_frame_host_->GetRemoteInterfaces()->GetInterface(
|
|
|
|
render_frame_.BindNewPipeAndPassReceiver());
|
|
|
|
}
|
|
|
|
return render_frame_;
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
void CefFrameHostImpl::SendToRenderFrame(const std::string& function_name,
|
|
|
|
RenderFrameAction action) {
|
2021-05-14 18:58:55 +02:00
|
|
|
if (!CEF_CURRENTLY_ON_UIT()) {
|
2021-05-21 03:42:58 +02:00
|
|
|
CEF_POST_TASK(CEF_UIT,
|
|
|
|
base::BindOnce(&CefFrameHostImpl::SendToRenderFrame, this,
|
|
|
|
function_name, std::move(action)));
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
2021-05-14 18:58:55 +02:00
|
|
|
}
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-21 03:42:58 +02:00
|
|
|
if (is_temporary()) {
|
|
|
|
LOG(WARNING) << function_name
|
|
|
|
<< " sent to temporary subframe will be ignored.";
|
|
|
|
return;
|
|
|
|
} else if (!render_frame_host_) {
|
|
|
|
// We've been detached.
|
|
|
|
LOG(WARNING) << function_name << " sent to detached "
|
|
|
|
<< (is_main_frame_ ? "main" : "sub") << "frame "
|
|
|
|
<< frame_util::GetFrameDebugString(frame_id_)
|
|
|
|
<< " will be ignored";
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
if (!is_attached_) {
|
|
|
|
// Queue actions until we're notified by the renderer that it's ready to
|
|
|
|
// handle them.
|
2021-05-21 03:42:58 +02:00
|
|
|
queued_actions_.push(std::make_pair(function_name, std::move(action)));
|
2021-05-14 18:58:55 +02:00
|
|
|
return;
|
|
|
|
}
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
auto& render_frame = GetRenderFrame();
|
|
|
|
if (!render_frame)
|
|
|
|
return;
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
std::move(action).Run(render_frame);
|
|
|
|
}
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::SendMessage(const std::string& name,
|
|
|
|
base::Value arguments) {
|
|
|
|
if (auto browser = GetBrowserHostBase()) {
|
|
|
|
if (auto client = browser->GetClient()) {
|
|
|
|
auto& list_value = base::Value::AsListValue(arguments);
|
2019-05-24 22:23:43 +02:00
|
|
|
CefRefPtr<CefProcessMessageImpl> message(new CefProcessMessageImpl(
|
2021-05-20 18:26:36 +02:00
|
|
|
name, std::move(const_cast<base::ListValue&>(list_value)),
|
|
|
|
/*read_only=*/true));
|
2021-05-14 18:58:55 +02:00
|
|
|
browser->GetClient()->OnProcessMessageReceived(
|
2019-05-24 22:23:43 +02:00
|
|
|
browser.get(), this, PID_RENDERER, message.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::FrameAttached() {
|
2021-05-21 03:42:58 +02:00
|
|
|
CEF_REQUIRE_UIT();
|
|
|
|
|
2021-06-09 22:54:50 +02:00
|
|
|
auto browser_info = GetBrowserInfo();
|
|
|
|
if (!browser_info) {
|
|
|
|
// Already Detached.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-19 02:45:05 +02:00
|
|
|
DCHECK(!is_attached_);
|
2021-05-14 18:58:55 +02:00
|
|
|
if (!is_attached_) {
|
|
|
|
is_attached_ = true;
|
2019-05-24 22:23:43 +02:00
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
auto& render_frame = GetRenderFrame();
|
|
|
|
while (!queued_actions_.empty()) {
|
|
|
|
if (render_frame) {
|
2021-05-21 03:42:58 +02:00
|
|
|
std::move(queued_actions_.front().second).Run(render_frame);
|
2021-05-14 18:58:55 +02:00
|
|
|
}
|
|
|
|
queued_actions_.pop();
|
|
|
|
}
|
2021-05-21 03:42:58 +02:00
|
|
|
|
2021-06-09 22:54:50 +02:00
|
|
|
browser_info->MaybeExecuteFrameNotification(base::BindOnce(
|
2021-05-21 03:42:58 +02:00
|
|
|
[](CefRefPtr<CefFrameHostImpl> self,
|
|
|
|
CefRefPtr<CefFrameHandler> handler) {
|
|
|
|
if (auto browser = self->GetBrowserHostBase()) {
|
|
|
|
handler->OnFrameAttached(browser, self);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
CefRefPtr<CefFrameHostImpl>(this)));
|
2021-05-14 18:58:55 +02:00
|
|
|
}
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::DidFinishFrameLoad(const GURL& validated_url,
|
|
|
|
int http_status_code) {
|
|
|
|
auto browser = GetBrowserHostBase();
|
|
|
|
if (browser)
|
|
|
|
browser->OnDidFinishLoad(this, validated_url, http_status_code);
|
2019-05-24 22:23:43 +02:00
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
void CefFrameHostImpl::UpdateDraggableRegions(
|
2021-06-04 03:34:56 +02:00
|
|
|
absl::optional<std::vector<cef::mojom::DraggableRegionEntryPtr>> regions) {
|
2021-05-14 18:58:55 +02:00
|
|
|
auto browser = GetBrowserHostBase();
|
|
|
|
if (!browser)
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
CefRefPtr<CefDragHandler> handler;
|
|
|
|
auto client = browser->GetClient();
|
|
|
|
if (client)
|
|
|
|
handler = client->GetDragHandler();
|
|
|
|
if (!handler)
|
2019-05-24 22:23:43 +02:00
|
|
|
return;
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
std::vector<CefDraggableRegion> draggable_regions;
|
|
|
|
if (regions) {
|
|
|
|
draggable_regions.reserve(regions->size());
|
|
|
|
|
|
|
|
for (const auto& region : *regions) {
|
|
|
|
const auto& rect = region->bounds;
|
|
|
|
const CefRect bounds(rect.x(), rect.y(), rect.width(), rect.height());
|
|
|
|
draggable_regions.push_back(
|
|
|
|
CefDraggableRegion(bounds, region->draggable));
|
|
|
|
}
|
2013-05-31 17:34:53 +02:00
|
|
|
}
|
|
|
|
|
2021-05-14 18:58:55 +02:00
|
|
|
handler->OnDraggableRegionsChanged(browser.get(), this, draggable_regions);
|
2013-05-31 17:34:53 +02:00
|
|
|
}
|
2017-05-31 17:33:30 +02:00
|
|
|
|
|
|
|
void CefExecuteJavaScriptWithUserGestureForTests(CefRefPtr<CefFrame> frame,
|
|
|
|
const CefString& javascript) {
|
|
|
|
CefFrameHostImpl* impl = static_cast<CefFrameHostImpl*>(frame.get());
|
2019-05-11 00:14:48 +02:00
|
|
|
if (impl)
|
|
|
|
impl->ExecuteJavaScriptWithUserGestureForTests(javascript);
|
2017-05-31 17:33:30 +02:00
|
|
|
}
|