electron/atom/renderer/api/atom_api_web_frame.cc

223 lines
8 KiB
C++
Raw Normal View History

// 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.
#include "atom/renderer/api/atom_api_web_frame.h"
#include "atom/common/api/event_emitter_caller.h"
2016-05-12 20:56:46 +00:00
#include "atom/common/native_mate_converters/blink_converter.h"
#include "atom/common/native_mate_converters/callback.h"
2015-05-29 05:47:09 +00:00
#include "atom/common/native_mate_converters/gfx_converter.h"
2014-10-24 10:24:12 +00:00
#include "atom/common/native_mate_converters/string16_converter.h"
2014-12-18 21:54:01 +00:00
#include "atom/renderer/api/atom_api_spell_check_client.h"
2014-12-08 16:05:34 +00:00
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_view.h"
2014-10-24 10:24:12 +00:00
#include "native_mate/dictionary.h"
#include "native_mate/object_template_builder.h"
2016-05-12 20:56:46 +00:00
#include "third_party/WebKit/public/web/WebCache.h"
2014-10-24 10:24:12 +00:00
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebScriptExecutionCallback.h"
2016-01-13 04:11:46 +00:00
#include "third_party/WebKit/public/web/WebScriptSource.h"
#include "third_party/WebKit/public/web/WebSecurityPolicy.h"
2014-10-24 10:24:12 +00:00
#include "third_party/WebKit/public/web/WebView.h"
#include "atom/common/node_includes.h"
namespace atom {
namespace api {
namespace {
class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
public:
using CompletionCallback =
base::Callback<void(
2016-02-22 14:00:21 +00:00
const v8::Local<v8::Value>& result)>;
explicit ScriptExecutionCallback(const CompletionCallback& callback)
: callback_(callback) {}
~ScriptExecutionCallback() {}
void completed(
const blink::WebVector<v8::Local<v8::Value>>& result) override {
if (!callback_.is_null() && !result.isEmpty() && !result[0].IsEmpty())
2016-02-22 14:00:21 +00:00
// Right now only single results per frame is supported.
callback_.Run(result[0]);
delete this;
}
private:
CompletionCallback callback_;
DISALLOW_COPY_AND_ASSIGN(ScriptExecutionCallback);
};
} // namespace
2016-04-25 01:17:54 +00:00
WebFrame::WebFrame(v8::Isolate* isolate)
2014-10-24 10:24:12 +00:00
: web_frame_(blink::WebLocalFrame::frameForCurrentContext()) {
2016-04-25 01:17:54 +00:00
Init(isolate);
2014-10-24 10:24:12 +00:00
}
WebFrame::~WebFrame() {
}
2014-10-24 10:44:15 +00:00
void WebFrame::SetName(const std::string& name) {
web_frame_->setName(blink::WebString::fromUTF8(name));
}
2014-10-24 10:24:12 +00:00
double WebFrame::SetZoomLevel(double level) {
double ret = web_frame_->view()->setZoomLevel(level);
2016-04-25 01:17:54 +00:00
mate::EmitEvent(isolate(), GetWrapper(), "zoom-level-changed", ret);
return ret;
2014-10-24 10:24:12 +00:00
}
double WebFrame::GetZoomLevel() const {
return web_frame_->view()->zoomLevel();
}
double WebFrame::SetZoomFactor(double factor) {
return blink::WebView::zoomLevelToZoomFactor(SetZoomLevel(
blink::WebView::zoomFactorToZoomLevel(factor)));
}
double WebFrame::GetZoomFactor() const {
return blink::WebView::zoomLevelToZoomFactor(GetZoomLevel());
}
2015-08-27 14:08:25 +00:00
void WebFrame::SetZoomLevelLimits(double min_level, double max_level) {
web_frame_->view()->setDefaultPageScaleLimits(min_level, max_level);
}
2015-05-22 11:11:22 +00:00
v8::Local<v8::Value> WebFrame::RegisterEmbedderCustomElement(
const base::string16& name, v8::Local<v8::Object> options) {
2014-10-24 10:24:12 +00:00
blink::WebExceptionCode c = 0;
return web_frame_->document().registerEmbedderCustomElement(name, options, c);
}
2015-05-29 05:47:09 +00:00
void WebFrame::RegisterElementResizeCallback(
int element_instance_id,
const GuestViewContainer::ResizeCallback& callback) {
auto guest_view_container = GuestViewContainer::FromID(element_instance_id);
if (guest_view_container)
guest_view_container->RegisterElementResizeCallback(callback);
}
2014-12-08 16:05:34 +00:00
void WebFrame::AttachGuest(int id) {
content::RenderFrame::FromWebFrame(web_frame_)->AttachGuest(id);
}
void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
const std::string& language,
bool auto_spell_correct_turned_on,
2015-05-22 11:11:22 +00:00
v8::Local<v8::Object> provider) {
if (!provider->Has(mate::StringToV8(args->isolate(), "spellCheck"))) {
args->ThrowError("\"spellCheck\" has to be defined");
return;
}
spell_check_client_.reset(new SpellCheckClient(
language, auto_spell_correct_turned_on, args->isolate(), provider));
web_frame_->view()->setSpellCheckClient(spell_check_client_.get());
2014-12-18 21:54:01 +00:00
}
void WebFrame::RegisterURLSchemeAsSecure(const std::string& scheme) {
// Register scheme to secure list (https, wss, data).
blink::WebSecurityPolicy::registerURLSchemeAsSecure(
blink::WebString::fromUTF8(scheme));
}
2015-11-13 08:03:40 +00:00
void WebFrame::RegisterURLSchemeAsBypassingCSP(const std::string& scheme) {
// Register scheme to bypass pages's Content Security Policy.
blink::WebSecurityPolicy::registerURLSchemeAsBypassingContentSecurityPolicy(
blink::WebString::fromUTF8(scheme));
}
void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme) {
// Register scheme to privileged list (https, wss, data, chrome-extension)
blink::WebString privileged_scheme(blink::WebString::fromUTF8(scheme));
blink::WebSecurityPolicy::registerURLSchemeAsSecure(privileged_scheme);
blink::WebSecurityPolicy::registerURLSchemeAsBypassingContentSecurityPolicy(
privileged_scheme);
blink::WebSecurityPolicy::registerURLSchemeAsAllowingServiceWorkers(
privileged_scheme);
blink::WebSecurityPolicy::registerURLSchemeAsSupportingFetchAPI(
privileged_scheme);
}
2016-01-13 03:21:16 +00:00
void WebFrame::InsertText(const std::string& text) {
web_frame_->insertText(blink::WebString::fromUTF8(text));
}
void WebFrame::ExecuteJavaScript(const base::string16& code,
mate::Arguments* args) {
bool has_user_gesture = false;
args->GetNext(&has_user_gesture);
ScriptExecutionCallback::CompletionCallback completion_callback;
args->GetNext(&completion_callback);
scoped_ptr<blink::WebScriptExecutionCallback> callback(
new ScriptExecutionCallback(completion_callback));
web_frame_->requestExecuteScriptAndReturnValue(
blink::WebScriptSource(code),
has_user_gesture,
callback.release());
2016-01-13 04:11:46 +00:00
}
2016-04-25 01:17:54 +00:00
// static
mate::Handle<WebFrame> WebFrame::Create(v8::Isolate* isolate) {
2016-04-25 01:27:54 +00:00
return mate::CreateHandle(isolate, new WebFrame(isolate));
2016-04-25 01:17:54 +00:00
}
2016-05-12 20:56:46 +00:00
v8::Local<v8::Value> WebFrame::GetResourceUsage(v8::Isolate* isolate) {
blink::WebCache::ResourceTypeStats stats;
blink::WebCache::getResourceTypeStats(&stats);
return mate::Converter<blink::WebCache::ResourceTypeStats>::ToV8(isolate, stats);
}
2016-04-25 01:17:54 +00:00
// static
void WebFrame::BuildPrototype(
v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> prototype) {
mate::ObjectTemplateBuilder(isolate, prototype)
2014-10-24 10:44:15 +00:00
.SetMethod("setName", &WebFrame::SetName)
2014-10-24 10:24:12 +00:00
.SetMethod("setZoomLevel", &WebFrame::SetZoomLevel)
.SetMethod("getZoomLevel", &WebFrame::GetZoomLevel)
.SetMethod("setZoomFactor", &WebFrame::SetZoomFactor)
.SetMethod("getZoomFactor", &WebFrame::GetZoomFactor)
2015-08-27 14:08:25 +00:00
.SetMethod("setZoomLevelLimits", &WebFrame::SetZoomLevelLimits)
2014-10-24 10:24:12 +00:00
.SetMethod("registerEmbedderCustomElement",
2014-12-08 16:05:34 +00:00
&WebFrame::RegisterEmbedderCustomElement)
2015-05-29 05:47:09 +00:00
.SetMethod("registerElementResizeCallback",
&WebFrame::RegisterElementResizeCallback)
2014-12-18 21:54:01 +00:00
.SetMethod("attachGuest", &WebFrame::AttachGuest)
.SetMethod("setSpellCheckProvider", &WebFrame::SetSpellCheckProvider)
2015-11-13 08:03:40 +00:00
.SetMethod("registerURLSchemeAsSecure",
&WebFrame::RegisterURLSchemeAsSecure)
2015-11-13 08:03:40 +00:00
.SetMethod("registerURLSchemeAsBypassingCSP",
&WebFrame::RegisterURLSchemeAsBypassingCSP)
.SetMethod("registerURLSchemeAsPrivileged",
2016-01-13 03:21:16 +00:00
&WebFrame::RegisterURLSchemeAsPrivileged)
2016-01-13 04:11:46 +00:00
.SetMethod("insertText", &WebFrame::InsertText)
2016-05-12 20:56:46 +00:00
.SetMethod("executeJavaScript", &WebFrame::ExecuteJavaScript)
.SetMethod("getResourceUsage", &WebFrame::GetResourceUsage);
2014-10-24 10:24:12 +00:00
}
} // namespace api
} // namespace atom
namespace {
2015-05-22 11:11:22 +00:00
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
2014-10-24 10:24:12 +00:00
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
dict.Set("webFrame", atom::api::WebFrame::Create(isolate));
}
} // namespace
NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_renderer_web_frame, Initialize)