2014-10-31 18:17:05 +00:00
|
|
|
// Copyright (c) 2014 GitHub, Inc.
|
2014-10-24 10:24:12 +00:00
|
|
|
// Use of this source code is governed by the MIT license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2020-03-13 23:13:05 +00:00
|
|
|
#include <limits>
|
2019-02-08 21:38:31 +00:00
|
|
|
#include <memory>
|
|
|
|
#include <string>
|
2024-01-11 01:00:37 +00:00
|
|
|
#include <string_view>
|
2019-01-24 16:18:54 +00:00
|
|
|
#include <utility>
|
2019-02-08 21:38:31 +00:00
|
|
|
#include <vector>
|
2019-01-24 16:18:54 +00:00
|
|
|
|
2020-07-24 07:08:04 +00:00
|
|
|
#include "base/command_line.h"
|
2016-05-12 21:36:49 +00:00
|
|
|
#include "base/memory/memory_pressure_listener.h"
|
2020-10-19 11:48:16 +00:00
|
|
|
#include "base/strings/utf_string_conversions.h"
|
|
|
|
#include "components/spellcheck/renderer/spellcheck.h"
|
2014-12-08 16:05:34 +00:00
|
|
|
#include "content/public/renderer/render_frame.h"
|
2018-08-16 22:57:40 +00:00
|
|
|
#include "content/public/renderer/render_frame_observer.h"
|
2017-11-24 06:34:20 +00:00
|
|
|
#include "content/public/renderer/render_frame_visitor.h"
|
2021-04-12 23:35:18 +00:00
|
|
|
#include "gin/handle.h"
|
|
|
|
#include "gin/object_template_builder.h"
|
|
|
|
#include "gin/wrappable.h"
|
2019-06-04 01:18:23 +00:00
|
|
|
#include "services/service_manager/public/cpp/interface_provider.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/common/api/api.mojom.h"
|
2019-10-31 07:56:00 +00:00
|
|
|
#include "shell/common/gin_converters/blink_converter.h"
|
2020-03-03 00:11:40 +00:00
|
|
|
#include "shell/common/gin_converters/callback_converter.h"
|
2020-11-10 17:06:03 +00:00
|
|
|
#include "shell/common/gin_converters/file_path_converter.h"
|
2022-09-07 07:46:37 +00:00
|
|
|
#include "shell/common/gin_converters/value_converter.h"
|
2019-10-31 07:56:00 +00:00
|
|
|
#include "shell/common/gin_helper/dictionary.h"
|
2020-04-03 02:59:19 +00:00
|
|
|
#include "shell/common/gin_helper/error_thrower.h"
|
2021-04-12 23:35:18 +00:00
|
|
|
#include "shell/common/gin_helper/function_template_extensions.h"
|
2019-11-01 06:10:32 +00:00
|
|
|
#include "shell/common/gin_helper/promise.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/common/node_includes.h"
|
2020-07-23 21:32:20 +00:00
|
|
|
#include "shell/common/options_switches.h"
|
2021-01-26 22:23:35 +00:00
|
|
|
#include "shell/renderer/api/context_bridge/object_cache.h"
|
|
|
|
#include "shell/renderer/api/electron_api_context_bridge.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/renderer/api/electron_api_spell_check_client.h"
|
2021-05-10 12:19:23 +00:00
|
|
|
#include "shell/renderer/renderer_client_base.h"
|
2022-02-08 16:33:21 +00:00
|
|
|
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
|
2019-10-18 19:57:34 +00:00
|
|
|
#include "third_party/blink/public/common/page/page_zoom.h"
|
|
|
|
#include "third_party/blink/public/common/web_cache/web_cache_resource_type_stats.h"
|
2020-11-10 17:06:03 +00:00
|
|
|
#include "third_party/blink/public/common/web_preferences/web_preferences.h"
|
2018-07-20 16:08:18 +00:00
|
|
|
#include "third_party/blink/public/platform/web_cache.h"
|
2019-01-21 20:45:15 +00:00
|
|
|
#include "third_party/blink/public/platform/web_isolated_world_info.h"
|
2019-01-12 01:00:43 +00:00
|
|
|
#include "third_party/blink/public/web/web_custom_element.h"
|
2018-07-20 16:08:18 +00:00
|
|
|
#include "third_party/blink/public/web/web_document.h"
|
|
|
|
#include "third_party/blink/public/web/web_element.h"
|
|
|
|
#include "third_party/blink/public/web/web_frame_widget.h"
|
|
|
|
#include "third_party/blink/public/web/web_input_method_controller.h"
|
|
|
|
#include "third_party/blink/public/web/web_local_frame.h"
|
|
|
|
#include "third_party/blink/public/web/web_script_execution_callback.h"
|
|
|
|
#include "third_party/blink/public/web/web_script_source.h"
|
|
|
|
#include "third_party/blink/public/web/web_view.h"
|
2021-10-25 21:11:24 +00:00
|
|
|
#include "third_party/blink/renderer/core/execution_context/execution_context.h" // nogncheck
|
|
|
|
#include "third_party/blink/renderer/core/frame/csp/content_security_policy.h" // nogncheck
|
2021-10-06 02:21:00 +00:00
|
|
|
#include "third_party/blink/renderer/platform/bindings/dom_wrapper_world.h" // nogncheck
|
2020-06-22 17:35:10 +00:00
|
|
|
#include "ui/base/ime/ime_text_span.h"
|
2018-10-27 00:31:56 +00:00
|
|
|
#include "url/url_util.h"
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2024-01-03 08:52:49 +00:00
|
|
|
#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
|
|
|
|
#include "components/spellcheck/renderer/spellcheck.h"
|
|
|
|
#include "components/spellcheck/renderer/spellcheck_provider.h"
|
|
|
|
#endif
|
|
|
|
|
2019-10-31 07:56:00 +00:00
|
|
|
namespace gin {
|
2017-08-30 21:31:21 +00:00
|
|
|
|
2019-07-17 21:34:05 +00:00
|
|
|
template <>
|
2022-03-25 01:39:03 +00:00
|
|
|
struct Converter<blink::WebCssOrigin> {
|
2019-07-17 21:34:05 +00:00
|
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
|
|
v8::Local<v8::Value> val,
|
2022-03-25 01:39:03 +00:00
|
|
|
blink::WebCssOrigin* out) {
|
2019-07-17 21:34:05 +00:00
|
|
|
std::string css_origin;
|
|
|
|
if (!ConvertFromV8(isolate, val, &css_origin))
|
|
|
|
return false;
|
|
|
|
if (css_origin == "user") {
|
2022-03-25 01:39:03 +00:00
|
|
|
*out = blink::WebCssOrigin::kUser;
|
2019-07-17 21:34:05 +00:00
|
|
|
} else if (css_origin == "author") {
|
2022-03-25 01:39:03 +00:00
|
|
|
*out = blink::WebCssOrigin::kAuthor;
|
2019-07-17 21:34:05 +00:00
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-10-31 07:56:00 +00:00
|
|
|
} // namespace gin
|
2017-08-30 21:31:21 +00:00
|
|
|
|
2014-10-24 10:24:12 +00:00
|
|
|
namespace electron {
|
|
|
|
|
2021-05-12 07:38:21 +00:00
|
|
|
content::RenderFrame* GetRenderFrame(v8::Local<v8::Object> value) {
|
2022-05-17 16:48:40 +00:00
|
|
|
v8::Local<v8::Context> context = value->GetCreationContextChecked();
|
2018-08-16 22:57:40 +00:00
|
|
|
if (context.IsEmpty())
|
|
|
|
return nullptr;
|
|
|
|
blink::WebLocalFrame* frame = blink::WebLocalFrame::FrameForContext(context);
|
|
|
|
if (!frame)
|
|
|
|
return nullptr;
|
|
|
|
return content::RenderFrame::FromWebFrame(frame);
|
|
|
|
}
|
|
|
|
|
2021-05-24 02:32:55 +00:00
|
|
|
namespace api {
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2020-11-14 00:18:16 +00:00
|
|
|
#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
bool SpellCheckWord(content::RenderFrame* render_frame,
|
2020-10-19 11:48:16 +00:00
|
|
|
const std::string& word,
|
2021-03-16 16:18:45 +00:00
|
|
|
std::vector<std::u16string>* optional_suggestions) {
|
2020-10-19 11:48:16 +00:00
|
|
|
size_t start;
|
|
|
|
size_t length;
|
|
|
|
|
2021-05-10 12:19:23 +00:00
|
|
|
RendererClientBase* client = RendererClientBase::Get();
|
2020-10-19 11:48:16 +00:00
|
|
|
|
2024-01-03 08:52:49 +00:00
|
|
|
mojo::Remote<spellcheck::mojom::SpellCheckHost> spellcheck_host;
|
|
|
|
render_frame->GetBrowserInterfaceBroker()->GetInterface(
|
|
|
|
spellcheck_host.BindNewPipeAndPassReceiver());
|
|
|
|
if (!spellcheck_host.is_bound())
|
|
|
|
return false;
|
|
|
|
|
2021-03-16 16:18:45 +00:00
|
|
|
std::u16string w = base::UTF8ToUTF16(word);
|
2024-01-03 08:52:49 +00:00
|
|
|
return client->GetSpellCheck()->SpellCheckWord(w.c_str(), 0, word.size(),
|
|
|
|
*spellcheck_host.get(), &start,
|
|
|
|
&length, optional_suggestions);
|
2020-10-19 11:48:16 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 00:18:16 +00:00
|
|
|
#endif
|
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
class ScriptExecutionCallback {
|
2016-02-17 17:03:27 +00:00
|
|
|
public:
|
2020-03-03 00:11:40 +00:00
|
|
|
// for compatibility with the older version of this, error is after result
|
|
|
|
using CompletionCallback =
|
|
|
|
base::OnceCallback<void(const v8::Local<v8::Value>& result,
|
|
|
|
const v8::Local<v8::Value>& error)>;
|
|
|
|
|
2019-08-23 00:03:28 +00:00
|
|
|
explicit ScriptExecutionCallback(
|
2020-03-03 00:11:40 +00:00
|
|
|
gin_helper::Promise<v8::Local<v8::Value>> promise,
|
|
|
|
CompletionCallback callback)
|
2021-04-08 16:03:57 +00:00
|
|
|
: promise_(std::move(promise)), callback_(std::move(callback)) {}
|
2020-03-03 00:11:40 +00:00
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
~ScriptExecutionCallback() = default;
|
2016-02-17 17:03:27 +00:00
|
|
|
|
2021-11-03 11:41:45 +00:00
|
|
|
// disable copy
|
|
|
|
ScriptExecutionCallback(const ScriptExecutionCallback&) = delete;
|
|
|
|
ScriptExecutionCallback& operator=(const ScriptExecutionCallback&) = delete;
|
|
|
|
|
2020-07-23 21:32:20 +00:00
|
|
|
void CopyResultToCallingContextAndFinalize(
|
|
|
|
v8::Isolate* isolate,
|
2021-01-26 22:23:35 +00:00
|
|
|
const v8::Local<v8::Object>& result) {
|
|
|
|
v8::MaybeLocal<v8::Value> maybe_result;
|
|
|
|
bool success = true;
|
|
|
|
std::string error_message =
|
|
|
|
"An unknown exception occurred while getting the result of the script";
|
2020-07-23 21:32:20 +00:00
|
|
|
{
|
|
|
|
v8::TryCatch try_catch(isolate);
|
2021-01-26 22:23:35 +00:00
|
|
|
context_bridge::ObjectCache object_cache;
|
2023-10-18 14:21:42 +00:00
|
|
|
v8::Local<v8::Context> source_context =
|
|
|
|
result->GetCreationContextChecked();
|
|
|
|
maybe_result =
|
|
|
|
PassValueToOtherContext(source_context, promise_.GetContext(), result,
|
|
|
|
source_context->Global(), &object_cache,
|
|
|
|
false, 0, BridgeErrorTarget::kSource);
|
2021-01-26 22:23:35 +00:00
|
|
|
if (maybe_result.IsEmpty() || try_catch.HasCaught()) {
|
|
|
|
success = false;
|
|
|
|
}
|
2020-07-23 21:32:20 +00:00
|
|
|
if (try_catch.HasCaught()) {
|
|
|
|
auto message = try_catch.Message();
|
|
|
|
|
2021-01-26 22:23:35 +00:00
|
|
|
if (!message.IsEmpty()) {
|
|
|
|
gin::ConvertFromV8(isolate, message->Get(), &error_message);
|
2020-07-23 21:32:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!success) {
|
|
|
|
// Failed convert so we send undefined everywhere
|
|
|
|
if (callback_)
|
|
|
|
std::move(callback_).Run(
|
|
|
|
v8::Undefined(isolate),
|
|
|
|
v8::Exception::Error(
|
|
|
|
v8::String::NewFromUtf8(isolate, error_message.c_str())
|
|
|
|
.ToLocalChecked()));
|
|
|
|
promise_.RejectWithErrorMessage(error_message);
|
|
|
|
} else {
|
|
|
|
v8::Local<v8::Context> context = promise_.GetContext();
|
|
|
|
v8::Context::Scope context_scope(context);
|
2021-01-26 22:23:35 +00:00
|
|
|
v8::Local<v8::Value> cloned_value = maybe_result.ToLocalChecked();
|
2020-07-23 21:32:20 +00:00
|
|
|
if (callback_)
|
|
|
|
std::move(callback_).Run(cloned_value, v8::Undefined(isolate));
|
|
|
|
promise_.Resolve(cloned_value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
void Completed(const blink::WebVector<v8::Local<v8::Value>>& result) {
|
2021-03-29 10:45:08 +00:00
|
|
|
v8::Isolate* isolate = promise_.isolate();
|
2019-06-05 22:43:02 +00:00
|
|
|
if (!result.empty()) {
|
|
|
|
if (!result[0].IsEmpty()) {
|
2020-07-23 21:32:20 +00:00
|
|
|
v8::Local<v8::Value> value = result[0];
|
2021-04-12 23:35:18 +00:00
|
|
|
// Either the result was created in the same world as the caller
|
|
|
|
// or the result is not an object and therefore does not have a
|
|
|
|
// prototype chain to protect
|
2020-07-23 21:32:20 +00:00
|
|
|
bool should_clone_value =
|
|
|
|
!(value->IsObject() &&
|
|
|
|
promise_.GetContext() ==
|
2022-05-17 16:48:40 +00:00
|
|
|
value.As<v8::Object>()->GetCreationContextChecked()) &&
|
2020-07-23 21:32:20 +00:00
|
|
|
value->IsObject();
|
|
|
|
if (should_clone_value) {
|
2021-01-26 22:23:35 +00:00
|
|
|
CopyResultToCallingContextAndFinalize(isolate,
|
|
|
|
value.As<v8::Object>());
|
2020-07-23 21:32:20 +00:00
|
|
|
} else {
|
|
|
|
// Right now only single results per frame is supported.
|
|
|
|
if (callback_)
|
|
|
|
std::move(callback_).Run(value, v8::Undefined(isolate));
|
|
|
|
promise_.Resolve(value);
|
|
|
|
}
|
2019-06-05 22:43:02 +00:00
|
|
|
} else {
|
2021-07-02 00:51:52 +00:00
|
|
|
const char error_message[] =
|
2019-06-05 22:43:02 +00:00
|
|
|
"Script failed to execute, this normally means an error "
|
2020-03-03 00:11:40 +00:00
|
|
|
"was thrown. Check the renderer console for the error.";
|
|
|
|
if (!callback_.is_null()) {
|
2020-07-23 21:32:20 +00:00
|
|
|
v8::Local<v8::Context> context = promise_.GetContext();
|
|
|
|
v8::Context::Scope context_scope(context);
|
2020-03-03 00:11:40 +00:00
|
|
|
std::move(callback_).Run(
|
|
|
|
v8::Undefined(isolate),
|
|
|
|
v8::Exception::Error(
|
|
|
|
v8::String::NewFromUtf8(isolate, error_message)
|
|
|
|
.ToLocalChecked()));
|
|
|
|
}
|
|
|
|
promise_.RejectWithErrorMessage(error_message);
|
2019-06-05 22:43:02 +00:00
|
|
|
}
|
|
|
|
} else {
|
2021-07-02 00:51:52 +00:00
|
|
|
const char error_message[] =
|
2019-06-05 22:43:02 +00:00
|
|
|
"WebFrame was removed before script could run. This normally means "
|
2020-03-03 00:11:40 +00:00
|
|
|
"the underlying frame was destroyed";
|
|
|
|
if (!callback_.is_null()) {
|
2020-07-23 21:32:20 +00:00
|
|
|
v8::Local<v8::Context> context = promise_.GetContext();
|
|
|
|
v8::Context::Scope context_scope(context);
|
2020-03-03 00:11:40 +00:00
|
|
|
std::move(callback_).Run(
|
|
|
|
v8::Undefined(isolate),
|
|
|
|
v8::Exception::Error(v8::String::NewFromUtf8(isolate, error_message)
|
|
|
|
.ToLocalChecked()));
|
|
|
|
}
|
|
|
|
promise_.RejectWithErrorMessage(error_message);
|
2019-06-05 22:43:02 +00:00
|
|
|
}
|
2016-02-17 17:03:27 +00:00
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2019-11-01 06:10:32 +00:00
|
|
|
gin_helper::Promise<v8::Local<v8::Value>> promise_;
|
2020-03-03 00:11:40 +00:00
|
|
|
CompletionCallback callback_;
|
2016-02-17 17:03:27 +00:00
|
|
|
};
|
|
|
|
|
2019-02-08 21:38:31 +00:00
|
|
|
class FrameSetSpellChecker : public content::RenderFrameVisitor {
|
2017-11-24 06:34:20 +00:00
|
|
|
public:
|
2019-02-08 21:38:31 +00:00
|
|
|
FrameSetSpellChecker(SpellCheckClient* spell_check_client,
|
|
|
|
content::RenderFrame* main_frame)
|
|
|
|
: spell_check_client_(spell_check_client), main_frame_(main_frame) {
|
|
|
|
content::RenderFrame::ForEach(this);
|
|
|
|
main_frame->GetWebFrame()->SetSpellCheckPanelHostClient(spell_check_client);
|
2017-11-24 06:34:20 +00:00
|
|
|
}
|
2019-02-08 21:38:31 +00:00
|
|
|
|
2021-11-03 11:41:45 +00:00
|
|
|
// disable copy
|
|
|
|
FrameSetSpellChecker(const FrameSetSpellChecker&) = delete;
|
|
|
|
FrameSetSpellChecker& operator=(const FrameSetSpellChecker&) = delete;
|
|
|
|
|
2017-11-24 06:34:20 +00:00
|
|
|
bool Visit(content::RenderFrame* render_frame) override {
|
2021-06-22 19:17:16 +00:00
|
|
|
if (render_frame->GetMainRenderFrame() == main_frame_ ||
|
2017-11-24 06:34:20 +00:00
|
|
|
(render_frame->IsMainFrame() && render_frame == main_frame_)) {
|
|
|
|
render_frame->GetWebFrame()->SetTextCheckClient(spell_check_client_);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
SpellCheckClient* spell_check_client_;
|
|
|
|
content::RenderFrame* main_frame_;
|
2019-02-08 21:38:31 +00:00
|
|
|
};
|
2016-02-17 17:03:27 +00:00
|
|
|
|
2019-09-13 14:26:59 +00:00
|
|
|
class SpellCheckerHolder final : public content::RenderFrameObserver {
|
2019-01-24 16:18:54 +00:00
|
|
|
public:
|
2019-02-08 21:38:31 +00:00
|
|
|
// Find existing holder for the |render_frame|.
|
|
|
|
static SpellCheckerHolder* FromRenderFrame(
|
|
|
|
content::RenderFrame* render_frame) {
|
|
|
|
for (auto* holder : instances_) {
|
|
|
|
if (holder->render_frame() == render_frame)
|
|
|
|
return holder;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
SpellCheckerHolder(content::RenderFrame* render_frame,
|
|
|
|
std::unique_ptr<SpellCheckClient> spell_check_client)
|
2019-01-24 16:18:54 +00:00
|
|
|
: content::RenderFrameObserver(render_frame),
|
2019-02-08 21:38:31 +00:00
|
|
|
spell_check_client_(std::move(spell_check_client)) {
|
|
|
|
DCHECK(!FromRenderFrame(render_frame));
|
|
|
|
instances_.insert(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
~SpellCheckerHolder() final { instances_.erase(this); }
|
|
|
|
|
|
|
|
void UnsetAndDestroy() {
|
|
|
|
FrameSetSpellChecker set_spell_checker(nullptr, render_frame());
|
|
|
|
delete this;
|
|
|
|
}
|
2019-01-24 16:18:54 +00:00
|
|
|
|
|
|
|
// RenderFrameObserver implementation.
|
|
|
|
void OnDestruct() final {
|
2019-02-08 21:38:31 +00:00
|
|
|
// Since we delete this in WillReleaseScriptContext, this method is unlikely
|
|
|
|
// to be called, but override anyway since I'm not sure if there are some
|
|
|
|
// corner cases.
|
|
|
|
//
|
|
|
|
// Note that while there are two "delete this", it is totally fine as the
|
|
|
|
// observer unsubscribes automatically in destructor and the other one won't
|
|
|
|
// be called.
|
|
|
|
//
|
|
|
|
// Also note that we should not call UnsetAndDestroy here, as the render
|
|
|
|
// frame is going to be destroyed.
|
2019-01-24 16:18:54 +00:00
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
2019-02-08 21:38:31 +00:00
|
|
|
void WillReleaseScriptContext(v8::Local<v8::Context> context,
|
|
|
|
int world_id) final {
|
|
|
|
// Unset spell checker when the script context is going to be released, as
|
|
|
|
// the spell check implementation lives there.
|
|
|
|
UnsetAndDestroy();
|
|
|
|
}
|
|
|
|
|
2019-01-24 16:18:54 +00:00
|
|
|
private:
|
2019-02-08 21:38:31 +00:00
|
|
|
static std::set<SpellCheckerHolder*> instances_;
|
|
|
|
|
2019-01-24 16:18:54 +00:00
|
|
|
std::unique_ptr<SpellCheckClient> spell_check_client_;
|
|
|
|
};
|
|
|
|
|
2019-02-08 21:38:31 +00:00
|
|
|
} // namespace
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
class WebFrameRenderer : public gin::Wrappable<WebFrameRenderer>,
|
|
|
|
public content::RenderFrameObserver {
|
|
|
|
public:
|
|
|
|
static gin::WrapperInfo kWrapperInfo;
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
static gin::Handle<WebFrameRenderer> Create(
|
|
|
|
v8::Isolate* isolate,
|
|
|
|
content::RenderFrame* render_frame) {
|
|
|
|
return gin::CreateHandle(isolate, new WebFrameRenderer(render_frame));
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
explicit WebFrameRenderer(content::RenderFrame* render_frame)
|
|
|
|
: content::RenderFrameObserver(render_frame) {
|
|
|
|
DCHECK(render_frame);
|
|
|
|
}
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
// gin::Wrappable:
|
|
|
|
gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
|
|
|
|
v8::Isolate* isolate) override {
|
|
|
|
return gin::Wrappable<WebFrameRenderer>::GetObjectTemplateBuilder(isolate)
|
|
|
|
.SetMethod("getWebFrameId", &WebFrameRenderer::GetWebFrameId)
|
|
|
|
.SetMethod("setName", &WebFrameRenderer::SetName)
|
|
|
|
.SetMethod("setZoomLevel", &WebFrameRenderer::SetZoomLevel)
|
|
|
|
.SetMethod("getZoomLevel", &WebFrameRenderer::GetZoomLevel)
|
|
|
|
.SetMethod("setZoomFactor", &WebFrameRenderer::SetZoomFactor)
|
|
|
|
.SetMethod("getZoomFactor", &WebFrameRenderer::GetZoomFactor)
|
|
|
|
.SetMethod("getWebPreference", &WebFrameRenderer::GetWebPreference)
|
|
|
|
#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
|
|
|
|
.SetMethod("isWordMisspelled", &WebFrameRenderer::IsWordMisspelled)
|
|
|
|
.SetMethod("getWordSuggestions", &WebFrameRenderer::GetWordSuggestions)
|
|
|
|
#endif
|
|
|
|
.SetMethod("setVisualZoomLevelLimits",
|
|
|
|
&WebFrameRenderer::SetVisualZoomLevelLimits)
|
|
|
|
.SetMethod("allowGuestViewElementDefinition",
|
2021-05-15 07:42:07 +00:00
|
|
|
&RendererClientBase::AllowGuestViewElementDefinition)
|
2021-04-12 23:35:18 +00:00
|
|
|
.SetMethod("insertText", &WebFrameRenderer::InsertText)
|
|
|
|
.SetMethod("insertCSS", &WebFrameRenderer::InsertCSS)
|
|
|
|
.SetMethod("removeInsertedCSS", &WebFrameRenderer::RemoveInsertedCSS)
|
2021-10-25 21:11:24 +00:00
|
|
|
.SetMethod("_isEvalAllowed", &WebFrameRenderer::IsEvalAllowed)
|
2021-04-12 23:35:18 +00:00
|
|
|
.SetMethod("executeJavaScript", &WebFrameRenderer::ExecuteJavaScript)
|
|
|
|
.SetMethod("executeJavaScriptInIsolatedWorld",
|
|
|
|
&WebFrameRenderer::ExecuteJavaScriptInIsolatedWorld)
|
|
|
|
.SetMethod("setIsolatedWorldInfo",
|
|
|
|
&WebFrameRenderer::SetIsolatedWorldInfo)
|
|
|
|
.SetMethod("getResourceUsage", &WebFrameRenderer::GetResourceUsage)
|
|
|
|
.SetMethod("clearCache", &WebFrameRenderer::ClearCache)
|
|
|
|
.SetMethod("setSpellCheckProvider",
|
|
|
|
&WebFrameRenderer::SetSpellCheckProvider)
|
|
|
|
// Frame navigators
|
|
|
|
.SetMethod("findFrameByRoutingId",
|
|
|
|
&WebFrameRenderer::FindFrameByRoutingId)
|
|
|
|
.SetMethod("getFrameForSelector",
|
|
|
|
&WebFrameRenderer::GetFrameForSelector)
|
|
|
|
.SetMethod("findFrameByName", &WebFrameRenderer::FindFrameByName)
|
|
|
|
.SetProperty("opener", &WebFrameRenderer::GetOpener)
|
|
|
|
.SetProperty("parent", &WebFrameRenderer::GetFrameParent)
|
|
|
|
.SetProperty("top", &WebFrameRenderer::GetTop)
|
|
|
|
.SetProperty("firstChild", &WebFrameRenderer::GetFirstChild)
|
|
|
|
.SetProperty("nextSibling", &WebFrameRenderer::GetNextSibling)
|
|
|
|
.SetProperty("routingId", &WebFrameRenderer::GetRoutingId);
|
2020-03-13 23:13:05 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
const char* GetTypeName() override { return "WebFrameRenderer"; }
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void OnDestruct() override {}
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
private:
|
|
|
|
bool MaybeGetRenderFrame(v8::Isolate* isolate,
|
2024-01-11 01:00:37 +00:00
|
|
|
const std::string_view method_name,
|
2021-04-12 23:35:18 +00:00
|
|
|
content::RenderFrame** render_frame_ptr) {
|
|
|
|
std::string error_msg;
|
|
|
|
if (!MaybeGetRenderFrame(&error_msg, method_name, render_frame_ptr)) {
|
|
|
|
gin_helper::ErrorThrower(isolate).ThrowError(error_msg);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2020-11-10 17:06:03 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
bool MaybeGetRenderFrame(std::string* error_msg,
|
2024-01-11 01:00:37 +00:00
|
|
|
const std::string_view method_name,
|
2021-04-12 23:35:18 +00:00
|
|
|
content::RenderFrame** render_frame_ptr) {
|
|
|
|
auto* frame = render_frame();
|
|
|
|
if (!frame) {
|
2023-06-12 07:55:22 +00:00
|
|
|
*error_msg = base::ToString("Render frame was torn down before webFrame.",
|
|
|
|
method_name, " could be executed");
|
2021-04-12 23:35:18 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*render_frame_ptr = frame;
|
|
|
|
return true;
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-05-24 02:32:55 +00:00
|
|
|
static v8::Local<v8::Value> CreateWebFrameRenderer(v8::Isolate* isolate,
|
|
|
|
blink::WebFrame* frame) {
|
|
|
|
if (frame && frame->IsWebLocalFrame()) {
|
|
|
|
auto* render_frame =
|
|
|
|
content::RenderFrame::FromWebFrame(frame->ToWebLocalFrame());
|
|
|
|
return WebFrameRenderer::Create(isolate, render_frame).ToV8();
|
|
|
|
} else {
|
|
|
|
return v8::Null(isolate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetName(v8::Isolate* isolate, const std::string& name) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "setName", &render_frame))
|
|
|
|
return;
|
2015-08-27 14:08:25 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
render_frame->GetWebFrame()->SetName(blink::WebString::FromUTF8(name));
|
|
|
|
}
|
2014-10-24 10:24:12 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetZoomLevel(v8::Isolate* isolate, double level) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "setZoomLevel", &render_frame))
|
|
|
|
return;
|
2015-05-29 05:47:09 +00:00
|
|
|
|
2022-03-19 02:50:05 +00:00
|
|
|
mojo::AssociatedRemote<mojom::ElectronWebContentsUtility>
|
|
|
|
web_contents_utility_remote;
|
2022-02-08 16:33:21 +00:00
|
|
|
render_frame->GetRemoteAssociatedInterfaces()->GetInterface(
|
2022-03-19 02:50:05 +00:00
|
|
|
&web_contents_utility_remote);
|
|
|
|
web_contents_utility_remote->SetTemporaryZoomLevel(level);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2018-08-16 22:57:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
double GetZoomLevel(v8::Isolate* isolate) {
|
|
|
|
double result = 0.0;
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "getZoomLevel", &render_frame))
|
|
|
|
return result;
|
2014-12-08 16:05:34 +00:00
|
|
|
|
2022-03-19 02:50:05 +00:00
|
|
|
mojo::AssociatedRemote<mojom::ElectronWebContentsUtility>
|
|
|
|
web_contents_utility_remote;
|
2022-02-08 16:33:21 +00:00
|
|
|
render_frame->GetRemoteAssociatedInterfaces()->GetInterface(
|
2022-03-19 02:50:05 +00:00
|
|
|
&web_contents_utility_remote);
|
|
|
|
web_contents_utility_remote->DoGetZoomLevel(&result);
|
2021-04-12 23:35:18 +00:00
|
|
|
return result;
|
|
|
|
}
|
2016-09-08 17:01:01 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetZoomFactor(gin_helper::ErrorThrower thrower, double factor) {
|
|
|
|
if (factor < std::numeric_limits<double>::epsilon()) {
|
|
|
|
thrower.ThrowError("'zoomFactor' must be a double greater than 0.0");
|
|
|
|
return;
|
|
|
|
}
|
2014-12-18 21:54:01 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
SetZoomLevel(thrower.isolate(), blink::PageZoomFactorToZoomLevel(factor));
|
2019-02-08 21:38:31 +00:00
|
|
|
}
|
2016-01-13 03:21:16 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
double GetZoomFactor(v8::Isolate* isolate) {
|
|
|
|
double zoom_level = GetZoomLevel(isolate);
|
|
|
|
return blink::PageZoomLevelToZoomFactor(zoom_level);
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetWebPreference(v8::Isolate* isolate,
|
|
|
|
std::string pref_name) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "getWebPreference", &render_frame))
|
|
|
|
return v8::Undefined(isolate);
|
|
|
|
|
|
|
|
const auto& prefs = render_frame->GetBlinkPreferences();
|
|
|
|
|
2022-06-15 20:22:28 +00:00
|
|
|
if (pref_name == "isWebView") {
|
2021-12-06 03:54:14 +00:00
|
|
|
// FIXME(zcbenz): For child windows opened with window.open('') from
|
|
|
|
// webview, the WebPreferences is inherited from webview and the value
|
|
|
|
// of |is_webview| is wrong.
|
|
|
|
// Please check ElectronRenderFrameObserver::DidInstallConditionalFeatures
|
|
|
|
// for the background.
|
|
|
|
auto* web_frame = render_frame->GetWebFrame();
|
|
|
|
if (web_frame->Opener())
|
|
|
|
return gin::ConvertToV8(isolate, false);
|
2021-07-28 22:32:53 +00:00
|
|
|
return gin::ConvertToV8(isolate, prefs.is_webview);
|
2021-04-12 23:35:18 +00:00
|
|
|
} else if (pref_name == options::kHiddenPage) {
|
|
|
|
// NOTE: hiddenPage is internal-only.
|
|
|
|
return gin::ConvertToV8(isolate, prefs.hidden_page);
|
|
|
|
} else if (pref_name == options::kNodeIntegration) {
|
|
|
|
return gin::ConvertToV8(isolate, prefs.node_integration);
|
|
|
|
} else if (pref_name == options::kWebviewTag) {
|
|
|
|
return gin::ConvertToV8(isolate, prefs.webview_tag);
|
|
|
|
}
|
|
|
|
return v8::Null(isolate);
|
2019-06-17 15:39:36 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetVisualZoomLevelLimits(v8::Isolate* isolate,
|
|
|
|
double min_level,
|
|
|
|
double max_level) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "setVisualZoomLevelLimits",
|
|
|
|
&render_frame))
|
|
|
|
return;
|
|
|
|
|
|
|
|
blink::WebFrame* web_frame = render_frame->GetWebFrame();
|
|
|
|
web_frame->View()->SetDefaultPageScaleLimits(min_level, max_level);
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-05-12 07:38:21 +00:00
|
|
|
static int GetWebFrameId(v8::Local<v8::Object> content_window) {
|
2021-04-12 23:35:18 +00:00
|
|
|
// Get the WebLocalFrame before (possibly) executing any user-space JS while
|
|
|
|
// getting the |params|. We track the status of the RenderFrame via an
|
|
|
|
// observer in case it is deleted during user code execution.
|
|
|
|
content::RenderFrame* render_frame = GetRenderFrame(content_window);
|
2021-05-15 07:42:07 +00:00
|
|
|
if (!render_frame)
|
2021-04-12 23:35:18 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
blink::WebLocalFrame* frame = render_frame->GetWebFrame();
|
|
|
|
// Parent must exist.
|
|
|
|
blink::WebFrame* parent_frame = frame->Parent();
|
|
|
|
DCHECK(parent_frame);
|
|
|
|
DCHECK(parent_frame->IsWebLocalFrame());
|
|
|
|
|
|
|
|
return render_frame->GetRoutingID();
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetSpellCheckProvider(gin_helper::ErrorThrower thrower,
|
|
|
|
v8::Isolate* isolate,
|
|
|
|
const std::string& language,
|
|
|
|
v8::Local<v8::Object> provider) {
|
|
|
|
auto context = isolate->GetCurrentContext();
|
|
|
|
if (!provider->Has(context, gin::StringToV8(isolate, "spellCheck"))
|
|
|
|
.ToChecked()) {
|
|
|
|
thrower.ThrowError("\"spellCheck\" has to be defined");
|
|
|
|
return;
|
|
|
|
}
|
2019-03-14 19:08:54 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
// Remove the old client.
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "setSpellCheckProvider", &render_frame))
|
|
|
|
return;
|
2020-03-03 00:11:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
auto* existing = SpellCheckerHolder::FromRenderFrame(render_frame);
|
|
|
|
if (existing)
|
|
|
|
existing->UnsetAndDestroy();
|
2019-03-14 19:08:54 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
// Set spellchecker for all live frames in the same process or
|
|
|
|
// in the sandbox mode for all live sub frames to this WebFrame.
|
|
|
|
auto spell_check_client =
|
|
|
|
std::make_unique<SpellCheckClient>(language, isolate, provider);
|
|
|
|
FrameSetSpellChecker spell_checker(spell_check_client.get(), render_frame);
|
2016-01-13 04:11:46 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
// Attach the spell checker to RenderFrame.
|
|
|
|
new SpellCheckerHolder(render_frame, std::move(spell_check_client));
|
|
|
|
}
|
|
|
|
|
|
|
|
void InsertText(v8::Isolate* isolate, const std::string& text) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "insertText", &render_frame))
|
|
|
|
return;
|
|
|
|
|
|
|
|
blink::WebFrame* web_frame = render_frame->GetWebFrame();
|
|
|
|
if (web_frame->IsWebLocalFrame()) {
|
|
|
|
web_frame->ToWebLocalFrame()
|
|
|
|
->FrameWidget()
|
|
|
|
->GetActiveWebInputMethodController()
|
|
|
|
->CommitText(blink::WebString::FromUTF8(text),
|
|
|
|
blink::WebVector<ui::ImeTextSpan>(), blink::WebRange(),
|
|
|
|
0);
|
|
|
|
}
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
std::u16string InsertCSS(v8::Isolate* isolate,
|
|
|
|
const std::string& css,
|
|
|
|
gin::Arguments* args) {
|
2022-03-25 01:39:03 +00:00
|
|
|
blink::WebCssOrigin css_origin = blink::WebCssOrigin::kAuthor;
|
2021-04-12 23:35:18 +00:00
|
|
|
|
|
|
|
gin_helper::Dictionary options;
|
|
|
|
if (args->GetNext(&options))
|
|
|
|
options.Get("cssOrigin", &css_origin);
|
|
|
|
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "insertCSS", &render_frame))
|
|
|
|
return std::u16string();
|
|
|
|
|
|
|
|
blink::WebFrame* web_frame = render_frame->GetWebFrame();
|
|
|
|
if (web_frame->IsWebLocalFrame()) {
|
|
|
|
return web_frame->ToWebLocalFrame()
|
|
|
|
->GetDocument()
|
|
|
|
.InsertStyleSheet(blink::WebString::FromUTF8(css), nullptr,
|
|
|
|
css_origin)
|
|
|
|
.Utf16();
|
|
|
|
}
|
|
|
|
return std::u16string();
|
|
|
|
}
|
2020-03-03 00:11:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void RemoveInsertedCSS(v8::Isolate* isolate, const std::u16string& key) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "removeInsertedCSS", &render_frame))
|
|
|
|
return;
|
2020-03-03 00:11:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
blink::WebFrame* web_frame = render_frame->GetWebFrame();
|
|
|
|
if (web_frame->IsWebLocalFrame()) {
|
|
|
|
web_frame->ToWebLocalFrame()->GetDocument().RemoveInsertedStyleSheet(
|
|
|
|
blink::WebString::FromUTF16(key));
|
|
|
|
}
|
|
|
|
}
|
2020-03-03 00:11:40 +00:00
|
|
|
|
2021-10-25 21:11:24 +00:00
|
|
|
bool IsEvalAllowed(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "isEvalAllowed", &render_frame))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
auto* context = blink::ExecutionContext::From(
|
|
|
|
render_frame->GetWebFrame()->MainWorldScriptContext());
|
|
|
|
return !context->GetContentSecurityPolicy()->ShouldCheckEval();
|
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Promise> ExecuteJavaScript(gin::Arguments* gin_args,
|
|
|
|
const std::u16string& code) {
|
|
|
|
gin_helper::Arguments* args = static_cast<gin_helper::Arguments*>(gin_args);
|
2017-11-15 10:14:41 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Isolate* isolate = args->isolate();
|
|
|
|
gin_helper::Promise<v8::Local<v8::Value>> promise(isolate);
|
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
2017-11-15 10:14:41 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
std::string error_msg;
|
|
|
|
if (!MaybeGetRenderFrame(&error_msg, "executeJavaScript", &render_frame)) {
|
|
|
|
promise.RejectWithErrorMessage(error_msg);
|
2019-03-14 19:08:54 +00:00
|
|
|
return handle;
|
2017-11-15 10:14:41 +00:00
|
|
|
}
|
|
|
|
|
2021-10-06 02:21:00 +00:00
|
|
|
const blink::WebScriptSource source{blink::WebString::FromUTF16(code)};
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
bool has_user_gesture = false;
|
|
|
|
args->GetNext(&has_user_gesture);
|
2017-08-30 21:31:21 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
ScriptExecutionCallback::CompletionCallback completion_callback;
|
|
|
|
args->GetNext(&completion_callback);
|
2019-03-14 19:08:54 +00:00
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
auto* self = new ScriptExecutionCallback(std::move(promise),
|
|
|
|
std::move(completion_callback));
|
|
|
|
|
2021-10-06 02:21:00 +00:00
|
|
|
render_frame->GetWebFrame()->RequestExecuteScript(
|
2023-03-10 16:07:42 +00:00
|
|
|
blink::DOMWrapperWorld::kMainWorldId, base::make_span(&source, 1u),
|
2022-09-07 07:46:37 +00:00
|
|
|
has_user_gesture ? blink::mojom::UserActivationOption::kActivate
|
|
|
|
: blink::mojom::UserActivationOption::kDoNotActivate,
|
|
|
|
blink::mojom::EvaluationTiming::kSynchronous,
|
|
|
|
blink::mojom::LoadEventBlockingOption::kDoNotBlock,
|
|
|
|
base::NullCallback(),
|
|
|
|
base::BindOnce(&ScriptExecutionCallback::Completed,
|
|
|
|
base::Unretained(self)),
|
2021-11-24 08:45:59 +00:00
|
|
|
blink::BackForwardCacheAware::kAllow,
|
2022-09-07 07:46:37 +00:00
|
|
|
blink::mojom::WantResultOption::kWantResult,
|
|
|
|
blink::mojom::PromiseResultOption::kDoNotWait);
|
2017-08-30 21:31:21 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
return handle;
|
|
|
|
}
|
2019-02-13 18:05:28 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Promise> ExecuteJavaScriptInIsolatedWorld(
|
|
|
|
gin::Arguments* gin_args,
|
|
|
|
int world_id,
|
|
|
|
const std::vector<gin_helper::Dictionary>& scripts) {
|
|
|
|
gin_helper::Arguments* args = static_cast<gin_helper::Arguments*>(gin_args);
|
|
|
|
|
|
|
|
v8::Isolate* isolate = args->isolate();
|
|
|
|
gin_helper::Promise<v8::Local<v8::Value>> promise(isolate);
|
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
|
|
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
std::string error_msg;
|
|
|
|
if (!MaybeGetRenderFrame(&error_msg, "executeJavaScriptInIsolatedWorld",
|
|
|
|
&render_frame)) {
|
|
|
|
promise.RejectWithErrorMessage(error_msg);
|
|
|
|
return handle;
|
|
|
|
}
|
2016-05-12 20:56:46 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
bool has_user_gesture = false;
|
|
|
|
args->GetNext(&has_user_gesture);
|
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
blink::mojom::EvaluationTiming script_execution_type =
|
|
|
|
blink::mojom::EvaluationTiming::kSynchronous;
|
|
|
|
blink::mojom::LoadEventBlockingOption load_blocking_option =
|
|
|
|
blink::mojom::LoadEventBlockingOption::kDoNotBlock;
|
|
|
|
std::string execution_type;
|
|
|
|
args->GetNext(&execution_type);
|
|
|
|
|
|
|
|
if (execution_type == "asynchronous") {
|
|
|
|
script_execution_type = blink::mojom::EvaluationTiming::kAsynchronous;
|
|
|
|
} else if (execution_type == "asynchronousBlockingOnload") {
|
|
|
|
script_execution_type = blink::mojom::EvaluationTiming::kAsynchronous;
|
|
|
|
load_blocking_option = blink::mojom::LoadEventBlockingOption::kBlock;
|
|
|
|
}
|
2021-04-12 23:35:18 +00:00
|
|
|
|
|
|
|
ScriptExecutionCallback::CompletionCallback completion_callback;
|
|
|
|
args->GetNext(&completion_callback);
|
|
|
|
|
|
|
|
std::vector<blink::WebScriptSource> sources;
|
2021-10-06 02:21:00 +00:00
|
|
|
sources.reserve(scripts.size());
|
2021-04-12 23:35:18 +00:00
|
|
|
|
|
|
|
for (const auto& script : scripts) {
|
|
|
|
std::u16string code;
|
|
|
|
std::u16string url;
|
|
|
|
script.Get("url", &url);
|
|
|
|
|
|
|
|
if (!script.Get("code", &code)) {
|
2021-07-02 00:51:52 +00:00
|
|
|
const char error_message[] = "Invalid 'code'";
|
2021-04-12 23:35:18 +00:00
|
|
|
if (!completion_callback.is_null()) {
|
|
|
|
std::move(completion_callback)
|
|
|
|
.Run(v8::Undefined(isolate),
|
|
|
|
v8::Exception::Error(
|
|
|
|
v8::String::NewFromUtf8(isolate, error_message)
|
|
|
|
.ToLocalChecked()));
|
|
|
|
}
|
|
|
|
promise.RejectWithErrorMessage(error_message);
|
|
|
|
return handle;
|
|
|
|
}
|
2020-11-14 00:18:16 +00:00
|
|
|
|
2021-10-06 02:21:00 +00:00
|
|
|
sources.emplace_back(blink::WebString::FromUTF16(code),
|
2022-01-10 22:31:39 +00:00
|
|
|
blink::WebURL(GURL(url)));
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2020-10-19 11:48:16 +00:00
|
|
|
|
2022-09-07 07:46:37 +00:00
|
|
|
// Deletes itself.
|
|
|
|
auto* self = new ScriptExecutionCallback(std::move(promise),
|
|
|
|
std::move(completion_callback));
|
|
|
|
|
2021-10-06 02:21:00 +00:00
|
|
|
render_frame->GetWebFrame()->RequestExecuteScript(
|
2022-09-07 07:46:37 +00:00
|
|
|
world_id, base::make_span(sources),
|
|
|
|
has_user_gesture ? blink::mojom::UserActivationOption::kActivate
|
|
|
|
: blink::mojom::UserActivationOption::kDoNotActivate,
|
|
|
|
script_execution_type, load_blocking_option, base::NullCallback(),
|
|
|
|
base::BindOnce(&ScriptExecutionCallback::Completed,
|
|
|
|
base::Unretained(self)),
|
2021-11-24 08:45:59 +00:00
|
|
|
blink::BackForwardCacheAware::kPossiblyDisallow,
|
2022-09-07 07:46:37 +00:00
|
|
|
blink::mojom::WantResultOption::kWantResult,
|
|
|
|
blink::mojom::PromiseResultOption::kDoNotWait);
|
2020-10-19 11:48:16 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
return handle;
|
|
|
|
}
|
2020-11-14 00:18:16 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void SetIsolatedWorldInfo(v8::Isolate* isolate,
|
|
|
|
int world_id,
|
|
|
|
const gin_helper::Dictionary& options) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "setIsolatedWorldInfo", &render_frame))
|
|
|
|
return;
|
|
|
|
|
|
|
|
std::string origin_url, security_policy, name;
|
|
|
|
options.Get("securityOrigin", &origin_url);
|
|
|
|
options.Get("csp", &security_policy);
|
|
|
|
options.Get("name", &name);
|
|
|
|
|
|
|
|
if (!security_policy.empty() && origin_url.empty()) {
|
|
|
|
gin_helper::ErrorThrower(isolate).ThrowError(
|
|
|
|
"If csp is specified, securityOrigin should also be specified");
|
|
|
|
return;
|
|
|
|
}
|
2016-05-12 21:36:49 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
blink::WebIsolatedWorldInfo info;
|
|
|
|
info.security_origin = blink::WebSecurityOrigin::CreateFromString(
|
|
|
|
blink::WebString::FromUTF8(origin_url));
|
|
|
|
info.content_security_policy = blink::WebString::FromUTF8(security_policy);
|
|
|
|
info.human_readable_name = blink::WebString::FromUTF8(name);
|
|
|
|
blink::SetIsolatedWorldInfo(world_id, info);
|
|
|
|
}
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
blink::WebCacheResourceTypeStats GetResourceUsage(v8::Isolate* isolate) {
|
|
|
|
blink::WebCacheResourceTypeStats stats;
|
|
|
|
blink::WebCache::GetResourceTypeStats(&stats);
|
|
|
|
return stats;
|
|
|
|
}
|
2020-04-03 02:59:19 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
|
|
|
|
bool IsWordMisspelled(v8::Isolate* isolate, const std::string& word) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "isWordMisspelled", &render_frame))
|
|
|
|
return false;
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
return !SpellCheckWord(render_frame, word, nullptr);
|
|
|
|
}
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
std::vector<std::u16string> GetWordSuggestions(v8::Isolate* isolate,
|
|
|
|
const std::string& word) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
std::vector<std::u16string> suggestions;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "getWordSuggestions", &render_frame))
|
|
|
|
return suggestions;
|
2020-04-03 02:59:19 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
SpellCheckWord(render_frame, word, &suggestions);
|
|
|
|
return suggestions;
|
|
|
|
}
|
|
|
|
#endif
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
void ClearCache(v8::Isolate* isolate) {
|
|
|
|
isolate->IdleNotificationDeadline(0.5);
|
|
|
|
blink::WebCache::Clear();
|
|
|
|
base::MemoryPressureListener::NotifyMemoryPressure(
|
|
|
|
base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
|
|
|
|
}
|
2020-04-03 02:59:19 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> FindFrameByRoutingId(v8::Isolate* isolate,
|
|
|
|
int routing_id) {
|
|
|
|
content::RenderFrame* render_frame =
|
|
|
|
content::RenderFrame::FromRoutingID(routing_id);
|
|
|
|
if (render_frame)
|
|
|
|
return WebFrameRenderer::Create(isolate, render_frame).ToV8();
|
|
|
|
else
|
|
|
|
return v8::Null(isolate);
|
|
|
|
}
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetOpener(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "opener", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->Opener();
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2020-04-03 02:59:19 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
// Don't name it as GetParent, Windows has API with same name.
|
|
|
|
v8::Local<v8::Value> GetFrameParent(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "parent", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->Parent();
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetTop(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "top", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->Top();
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2018-01-09 19:41:40 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetFirstChild(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "firstChild", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->FirstChild();
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2018-04-26 10:17:55 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetNextSibling(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "nextSibling", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->NextSibling();
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2020-04-03 02:59:19 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> GetFrameForSelector(v8::Isolate* isolate,
|
|
|
|
const std::string& selector) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "getFrameForSelector", &render_frame))
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebElement element =
|
|
|
|
render_frame->GetWebFrame()->GetDocument().QuerySelector(
|
|
|
|
blink::WebString::FromUTF8(selector));
|
|
|
|
if (element.IsNull()) // not found
|
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = blink::WebFrame::FromFrameOwnerElement(element);
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2021-04-12 23:35:18 +00:00
|
|
|
}
|
2018-04-26 10:17:55 +00:00
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
v8::Local<v8::Value> FindFrameByName(v8::Isolate* isolate,
|
|
|
|
const std::string& name) {
|
|
|
|
content::RenderFrame* render_frame;
|
2021-05-24 02:32:55 +00:00
|
|
|
if (!MaybeGetRenderFrame(isolate, "findFrameByName", &render_frame))
|
2021-04-12 23:35:18 +00:00
|
|
|
return v8::Null(isolate);
|
|
|
|
|
|
|
|
blink::WebFrame* frame = render_frame->GetWebFrame()->FindFrameByName(
|
|
|
|
blink::WebString::FromUTF8(name));
|
2021-05-24 02:32:55 +00:00
|
|
|
return CreateWebFrameRenderer(isolate, frame);
|
2020-04-03 02:59:19 +00:00
|
|
|
}
|
|
|
|
|
2021-04-12 23:35:18 +00:00
|
|
|
int GetRoutingId(v8::Isolate* isolate) {
|
|
|
|
content::RenderFrame* render_frame;
|
|
|
|
if (!MaybeGetRenderFrame(isolate, "routingId", &render_frame))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return render_frame->GetRoutingID();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
gin::WrapperInfo WebFrameRenderer::kWrapperInfo = {gin::kEmbedderNativeGin};
|
|
|
|
|
|
|
|
// static
|
|
|
|
std::set<SpellCheckerHolder*> SpellCheckerHolder::instances_;
|
2014-10-24 10:24:12 +00:00
|
|
|
|
|
|
|
} // namespace api
|
|
|
|
|
|
|
|
} // namespace electron
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
void Initialize(v8::Local<v8::Object> exports,
|
|
|
|
v8::Local<v8::Value> unused,
|
|
|
|
v8::Local<v8::Context> context,
|
|
|
|
void* priv) {
|
2019-02-08 21:38:31 +00:00
|
|
|
using namespace electron::api; // NOLINT(build/namespaces)
|
|
|
|
|
2014-10-24 10:24:12 +00:00
|
|
|
v8::Isolate* isolate = context->GetIsolate();
|
2019-10-31 07:56:00 +00:00
|
|
|
gin_helper::Dictionary dict(isolate, exports);
|
2021-05-24 02:32:55 +00:00
|
|
|
dict.Set("mainFrame", WebFrameRenderer::Create(
|
|
|
|
isolate, electron::GetRenderFrame(exports)));
|
2014-10-24 10:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2023-02-09 01:31:38 +00:00
|
|
|
NODE_LINKED_BINDING_CONTEXT_AWARE(electron_renderer_web_frame, Initialize)
|