refactor: use mojo for electron internal IPC (#17406)
* refactor: use mojo for electron internal IPC
* add sender_id, drop MessageSync
* remove usages of AtomFrameMsg_Message
* iwyu
* first draft of renderer->browser direction
* refactor to reuse a single ipc interface
* implement TakeHeapSnapshot through mojo
* the rest of the owl^WtakeHeapSnapshot mojofication
* remove no-op overrides in AtomRendererClient
* delete renderer-side ElectronApiServiceImpl when its pipe is destroyed
* looks like we don't need to overlay the renderer manifest after all
* don't try to send 2 replies to a sync rpc
* undo changes to manifests.cc
* unify sandboxed + unsandboxed ipc events
* lint
* register ElectronBrowser mojo service on devtools WebContents
* fix takeHeapSnapshopt failure paths
* {electron_api => atom}::mojom
* add send_to_all to ElectronRenderer::Message
* keep interface alive until callback is called
* review comments
* use GetContext from RendererClientBase
* robustify a test that uses window.open
* MessageSync posts a task to put sync messages in the same queue as async ones
* add v8::MicrotasksScope and node::CallbackScope
* iwyu
* use weakptr to api::WebContents instead of Unretained
* make MessageSync an asynchronous message & use non-associated interface
* iwyu + comments
* remove unused WeakPtrFactory
* inline OnRendererMessage[Sync]
* cleanups & comments
* use helper methods instead of inline lambdas
* remove unneeded async in test
* add mojo to manifests deps
* add gn check for //electron/manifests and mojo
* don't register renderer side service until preload has been run
* update gn check targets list
* move interface registration back to RenderFrameCreated
This commit is contained in:
Jeremy Apthorp
GitHub
parent
5b696491db
commit
53f6cbccbf
32 changed files with 620 additions and 401 deletions
|
|
@ -8,10 +8,16 @@
|
|||
#include "atom/common/native_mate_converters/value_converter.h"
|
||||
#include "atom/common/node_bindings.h"
|
||||
#include "atom/common/node_includes.h"
|
||||
#include "base/task/post_task.h"
|
||||
#include "base/values.h"
|
||||
#include "content/public/renderer/render_frame.h"
|
||||
#include "electron/atom/common/api/api.mojom.h"
|
||||
#include "native_mate/arguments.h"
|
||||
#include "native_mate/dictionary.h"
|
||||
#include "native_mate/handle.h"
|
||||
#include "native_mate/object_template_builder.h"
|
||||
#include "native_mate/wrappable.h"
|
||||
#include "services/service_manager/public/cpp/interface_provider.h"
|
||||
#include "third_party/blink/public/web/web_local_frame.h"
|
||||
|
||||
using blink::WebLocalFrame;
|
||||
|
|
@ -27,40 +33,91 @@ RenderFrame* GetCurrentRenderFrame() {
|
|||
return RenderFrame::FromWebFrame(frame);
|
||||
}
|
||||
|
||||
void Send(mate::Arguments* args,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& arguments) {
|
||||
RenderFrame* render_frame = GetCurrentRenderFrame();
|
||||
if (render_frame == nullptr)
|
||||
return;
|
||||
class IPCRenderer : public mate::Wrappable<IPCRenderer> {
|
||||
public:
|
||||
explicit IPCRenderer(v8::Isolate* isolate) {
|
||||
Init(isolate);
|
||||
RenderFrame* render_frame = GetCurrentRenderFrame();
|
||||
DCHECK(render_frame);
|
||||
render_frame->GetRemoteInterfaces()->GetInterface(
|
||||
mojo::MakeRequest(&electron_browser_ptr_));
|
||||
}
|
||||
static void BuildPrototype(v8::Isolate* isolate,
|
||||
v8::Local<v8::FunctionTemplate> prototype) {
|
||||
prototype->SetClassName(mate::StringToV8(isolate, "IPCRenderer"));
|
||||
mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
|
||||
.SetMethod("send", &IPCRenderer::Send)
|
||||
.SetMethod("sendSync", &IPCRenderer::SendSync);
|
||||
}
|
||||
static mate::Handle<IPCRenderer> Create(v8::Isolate* isolate) {
|
||||
return mate::CreateHandle(isolate, new IPCRenderer(isolate));
|
||||
}
|
||||
|
||||
bool success = render_frame->Send(new AtomFrameHostMsg_Message(
|
||||
render_frame->GetRoutingID(), internal, channel, arguments));
|
||||
void Send(mate::Arguments* args,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& arguments) {
|
||||
electron_browser_ptr_->Message(internal, channel, arguments.Clone());
|
||||
}
|
||||
|
||||
if (!success)
|
||||
args->ThrowError("Unable to send AtomFrameHostMsg_Message");
|
||||
}
|
||||
base::Value SendSync(mate::Arguments* args,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& arguments) {
|
||||
base::Value result;
|
||||
|
||||
base::ListValue SendSync(mate::Arguments* args,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& arguments) {
|
||||
base::ListValue result;
|
||||
// A task is posted to a separate thread to execute the request so that
|
||||
// this thread may block on a waitable event. It is safe to pass raw
|
||||
// pointers to |result| and |event| as this stack frame will survive until
|
||||
// the request is complete.
|
||||
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
|
||||
base::CreateSingleThreadTaskRunnerWithTraits({});
|
||||
|
||||
RenderFrame* render_frame = GetCurrentRenderFrame();
|
||||
if (render_frame == nullptr)
|
||||
base::WaitableEvent response_received_event;
|
||||
|
||||
// We unbind the interface from this thread to pass it over to the worker
|
||||
// thread temporarily. This requires that no callbacks be pending for this
|
||||
// interface.
|
||||
auto interface_info = electron_browser_ptr_.PassInterface();
|
||||
task_runner->PostTask(
|
||||
FROM_HERE, base::BindOnce(&IPCRenderer::SendMessageSyncOnWorkerThread,
|
||||
base::Unretained(&interface_info),
|
||||
base::Unretained(&response_received_event),
|
||||
base::Unretained(&result), internal, channel,
|
||||
base::Unretained(&arguments)));
|
||||
response_received_event.Wait();
|
||||
electron_browser_ptr_.Bind(std::move(interface_info));
|
||||
return result;
|
||||
}
|
||||
|
||||
IPC::SyncMessage* message = new AtomFrameHostMsg_Message_Sync(
|
||||
render_frame->GetRoutingID(), internal, channel, arguments, &result);
|
||||
bool success = render_frame->Send(message);
|
||||
private:
|
||||
static void SendMessageSyncOnWorkerThread(
|
||||
atom::mojom::ElectronBrowserPtrInfo* interface_info,
|
||||
base::WaitableEvent* event,
|
||||
base::Value* result,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue* arguments) {
|
||||
atom::mojom::ElectronBrowserPtr browser_ptr(std::move(*interface_info));
|
||||
browser_ptr->MessageSync(
|
||||
internal, channel, arguments->Clone(),
|
||||
base::BindOnce(&IPCRenderer::ReturnSyncResponseToMainThread,
|
||||
std::move(browser_ptr), base::Unretained(interface_info),
|
||||
base::Unretained(event), base::Unretained(result)));
|
||||
}
|
||||
static void ReturnSyncResponseToMainThread(
|
||||
atom::mojom::ElectronBrowserPtr ptr,
|
||||
atom::mojom::ElectronBrowserPtrInfo* interface_info,
|
||||
base::WaitableEvent* event,
|
||||
base::Value* result,
|
||||
base::Value response) {
|
||||
*result = std::move(response);
|
||||
*interface_info = ptr.PassInterface();
|
||||
event->Signal();
|
||||
}
|
||||
|
||||
if (!success)
|
||||
args->ThrowError("Unable to send AtomFrameHostMsg_Message_Sync");
|
||||
|
||||
return result;
|
||||
}
|
||||
atom::mojom::ElectronBrowserPtr electron_browser_ptr_;
|
||||
};
|
||||
|
||||
void SendTo(mate::Arguments* args,
|
||||
bool internal,
|
||||
|
|
@ -99,8 +156,7 @@ void Initialize(v8::Local<v8::Object> exports,
|
|||
v8::Local<v8::Context> context,
|
||||
void* priv) {
|
||||
mate::Dictionary dict(context->GetIsolate(), exports);
|
||||
dict.SetMethod("send", &Send);
|
||||
dict.SetMethod("sendSync", &SendSync);
|
||||
dict.Set("ipc", IPCRenderer::Create(context->GetIsolate()));
|
||||
dict.SetMethod("sendTo", &SendTo);
|
||||
dict.SetMethod("sendToHost", &SendToHost);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,20 +9,21 @@
|
|||
|
||||
#include "atom/common/api/api_messages.h"
|
||||
#include "atom/common/api/event_emitter_caller.h"
|
||||
#include "atom/common/heap_snapshot.h"
|
||||
#include "atom/common/native_mate_converters/value_converter.h"
|
||||
#include "atom/common/node_includes.h"
|
||||
#include "atom/common/options_switches.h"
|
||||
#include "base/command_line.h"
|
||||
#include "base/strings/string_number_conversions.h"
|
||||
#include "base/threading/thread_restrictions.h"
|
||||
#include "base/trace_event/trace_event.h"
|
||||
#include "content/public/renderer/render_frame.h"
|
||||
#include "content/public/renderer/render_view.h"
|
||||
#include "electron/atom/common/api/api.mojom.h"
|
||||
#include "ipc/ipc_message_macros.h"
|
||||
#include "mojo/public/cpp/bindings/associated_binding.h"
|
||||
#include "native_mate/dictionary.h"
|
||||
#include "net/base/net_module.h"
|
||||
#include "net/grit/net_resources.h"
|
||||
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
|
||||
#include "third_party/blink/public/platform/web_isolated_world_info.h"
|
||||
#include "third_party/blink/public/web/blink.h"
|
||||
#include "third_party/blink/public/web/web_document.h"
|
||||
|
|
@ -36,32 +37,6 @@ namespace atom {
|
|||
|
||||
namespace {
|
||||
|
||||
bool GetIPCObject(v8::Isolate* isolate,
|
||||
v8::Local<v8::Context> context,
|
||||
bool internal,
|
||||
v8::Local<v8::Object>* ipc) {
|
||||
v8::Local<v8::String> key =
|
||||
mate::StringToV8(isolate, internal ? "ipc-internal" : "ipc");
|
||||
v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, key);
|
||||
v8::Local<v8::Object> global_object = context->Global();
|
||||
v8::Local<v8::Value> value;
|
||||
if (!global_object->GetPrivate(context, privateKey).ToLocal(&value))
|
||||
return false;
|
||||
if (value.IsEmpty() || !value->IsObject())
|
||||
return false;
|
||||
*ipc = value->ToObject(isolate);
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<v8::Local<v8::Value>> ListValueToVector(
|
||||
v8::Isolate* isolate,
|
||||
const base::ListValue& list) {
|
||||
v8::Local<v8::Value> array = mate::ConvertToV8(isolate, list);
|
||||
std::vector<v8::Local<v8::Value>> result;
|
||||
mate::ConvertFromV8(isolate, array, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
base::StringPiece NetResourceProvider(int key) {
|
||||
if (key == IDR_DIR_HEADER_HTML) {
|
||||
base::StringPiece html_data =
|
||||
|
|
@ -88,10 +63,6 @@ void AtomRenderFrameObserver::DidClearWindowObject() {
|
|||
renderer_client_->DidClearWindowObject(render_frame_);
|
||||
}
|
||||
|
||||
void AtomRenderFrameObserver::DidCreateDocumentElement() {
|
||||
document_created_ = true;
|
||||
}
|
||||
|
||||
void AtomRenderFrameObserver::DidCreateScriptContext(
|
||||
v8::Handle<v8::Context> context,
|
||||
int world_id) {
|
||||
|
|
@ -182,93 +153,4 @@ bool AtomRenderFrameObserver::ShouldNotifyClient(int world_id) {
|
|||
return IsMainWorld(world_id);
|
||||
}
|
||||
|
||||
bool AtomRenderFrameObserver::OnMessageReceived(const IPC::Message& message) {
|
||||
bool handled = true;
|
||||
IPC_BEGIN_MESSAGE_MAP(AtomRenderFrameObserver, message)
|
||||
IPC_MESSAGE_HANDLER(AtomFrameMsg_Message, OnBrowserMessage)
|
||||
IPC_MESSAGE_HANDLER(AtomFrameMsg_TakeHeapSnapshot, OnTakeHeapSnapshot)
|
||||
IPC_MESSAGE_UNHANDLED(handled = false)
|
||||
IPC_END_MESSAGE_MAP()
|
||||
|
||||
return handled;
|
||||
}
|
||||
|
||||
void AtomRenderFrameObserver::OnBrowserMessage(bool internal,
|
||||
bool send_to_all,
|
||||
const std::string& channel,
|
||||
const base::ListValue& args,
|
||||
int32_t sender_id) {
|
||||
// Don't handle browser messages before document element is created.
|
||||
// When we receive a message from the browser, we try to transfer it
|
||||
// to a web page, and when we do that Blink creates an empty
|
||||
// document element if it hasn't been created yet, and it makes our init
|
||||
// script to run while `window.location` is still "about:blank".
|
||||
if (!document_created_)
|
||||
return;
|
||||
|
||||
blink::WebLocalFrame* frame = render_frame_->GetWebFrame();
|
||||
if (!frame)
|
||||
return;
|
||||
|
||||
EmitIPCEvent(frame, internal, channel, args, sender_id);
|
||||
|
||||
// Also send the message to all sub-frames.
|
||||
// TODO(MarshallOfSound): Completely move this logic to the main process
|
||||
if (send_to_all) {
|
||||
for (blink::WebFrame* child = frame->FirstChild(); child;
|
||||
child = child->NextSibling())
|
||||
if (child->IsWebLocalFrame()) {
|
||||
EmitIPCEvent(child->ToWebLocalFrame(), internal, channel, args,
|
||||
sender_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AtomRenderFrameObserver::OnTakeHeapSnapshot(
|
||||
IPC::PlatformFileForTransit file_handle,
|
||||
const std::string& channel) {
|
||||
base::ThreadRestrictions::ScopedAllowIO allow_io;
|
||||
|
||||
auto file = IPC::PlatformFileForTransitToFile(file_handle);
|
||||
bool success = TakeHeapSnapshot(blink::MainThreadIsolate(), &file);
|
||||
|
||||
base::ListValue args;
|
||||
args.AppendBoolean(success);
|
||||
|
||||
render_frame_->Send(new AtomFrameHostMsg_Message(
|
||||
render_frame_->GetRoutingID(), true, channel, args));
|
||||
}
|
||||
|
||||
void AtomRenderFrameObserver::EmitIPCEvent(blink::WebLocalFrame* frame,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& args,
|
||||
int32_t sender_id) {
|
||||
if (!frame)
|
||||
return;
|
||||
|
||||
v8::Isolate* isolate = blink::MainThreadIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
|
||||
v8::Local<v8::Context> context = renderer_client_->GetContext(frame, isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
|
||||
// Only emit IPC event for context with node integration.
|
||||
node::Environment* env = node::Environment::GetCurrent(context);
|
||||
if (!env)
|
||||
return;
|
||||
|
||||
v8::Local<v8::Object> ipc;
|
||||
if (GetIPCObject(isolate, context, internal, &ipc)) {
|
||||
TRACE_EVENT0("devtools.timeline", "FunctionCall");
|
||||
auto args_vector = ListValueToVector(isolate, args);
|
||||
// Insert the Event object, event.sender is ipc.
|
||||
mate::Dictionary event = mate::Dictionary::CreateEmpty(isolate);
|
||||
event.Set("sender", ipc);
|
||||
event.Set("senderId", sender_id);
|
||||
args_vector.insert(args_vector.begin(), event.GetHandle());
|
||||
mate::EmitEvent(isolate, ipc, channel, args_vector);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
|
|
|
|||
|
|
@ -51,32 +51,17 @@ class AtomRenderFrameObserver : public content::RenderFrameObserver {
|
|||
void WillReleaseScriptContext(v8::Local<v8::Context> context,
|
||||
int world_id) override;
|
||||
void OnDestruct() override;
|
||||
bool OnMessageReceived(const IPC::Message& message) override;
|
||||
void DidCreateDocumentElement() override;
|
||||
|
||||
protected:
|
||||
virtual void EmitIPCEvent(blink::WebLocalFrame* frame,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& args,
|
||||
int32_t sender_id);
|
||||
|
||||
private:
|
||||
bool ShouldNotifyClient(int world_id);
|
||||
void CreateIsolatedWorldContext();
|
||||
bool IsMainWorld(int world_id);
|
||||
bool IsIsolatedWorld(int world_id);
|
||||
void OnBrowserMessage(bool internal,
|
||||
bool send_to_all,
|
||||
const std::string& channel,
|
||||
const base::ListValue& args,
|
||||
int32_t sender_id);
|
||||
void OnTakeHeapSnapshot(IPC::PlatformFileForTransit file_handle,
|
||||
const std::string& channel);
|
||||
|
||||
content::RenderFrame* render_frame_;
|
||||
RendererClientBase* renderer_client_;
|
||||
bool document_created_ = false;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(AtomRenderFrameObserver);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -41,20 +41,12 @@ AtomRendererClient::~AtomRendererClient() {
|
|||
asar::ClearArchives();
|
||||
}
|
||||
|
||||
void AtomRendererClient::RenderThreadStarted() {
|
||||
RendererClientBase::RenderThreadStarted();
|
||||
}
|
||||
|
||||
void AtomRendererClient::RenderFrameCreated(
|
||||
content::RenderFrame* render_frame) {
|
||||
new AtomRenderFrameObserver(render_frame, this);
|
||||
RendererClientBase::RenderFrameCreated(render_frame);
|
||||
}
|
||||
|
||||
void AtomRendererClient::RenderViewCreated(content::RenderView* render_view) {
|
||||
RendererClientBase::RenderViewCreated(render_view);
|
||||
}
|
||||
|
||||
void AtomRendererClient::RunScriptsAtDocumentStart(
|
||||
content::RenderFrame* render_frame) {
|
||||
// Inform the document start pharse.
|
||||
|
|
|
|||
|
|
@ -39,9 +39,7 @@ class AtomRendererClient : public RendererClientBase {
|
|||
|
||||
private:
|
||||
// content::ContentRendererClient:
|
||||
void RenderThreadStarted() override;
|
||||
void RenderFrameCreated(content::RenderFrame*) override;
|
||||
void RenderViewCreated(content::RenderView*) override;
|
||||
void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override;
|
||||
void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override;
|
||||
bool ShouldFork(blink::WebLocalFrame* frame,
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ namespace atom {
|
|||
|
||||
namespace {
|
||||
|
||||
const char kIpcKey[] = "ipcNative";
|
||||
const char kLifecycleKey[] = "lifecycle";
|
||||
const char kModuleCacheKey[] = "native-module-cache";
|
||||
|
||||
bool IsDevTools(content::RenderFrame* render_frame) {
|
||||
|
|
@ -91,41 +91,26 @@ v8::Local<v8::Value> CreatePreloadScript(v8::Isolate* isolate,
|
|||
preloadSrc);
|
||||
}
|
||||
|
||||
class AtomSandboxedRenderFrameObserver : public AtomRenderFrameObserver {
|
||||
public:
|
||||
AtomSandboxedRenderFrameObserver(content::RenderFrame* render_frame,
|
||||
AtomSandboxedRendererClient* renderer_client)
|
||||
: AtomRenderFrameObserver(render_frame, renderer_client),
|
||||
renderer_client_(renderer_client) {}
|
||||
|
||||
protected:
|
||||
void EmitIPCEvent(blink::WebLocalFrame* frame,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const base::ListValue& args,
|
||||
int32_t sender_id) override {
|
||||
if (!frame)
|
||||
return;
|
||||
|
||||
auto* isolate = blink::MainThreadIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
|
||||
auto context = renderer_client_->GetContext(frame, isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
|
||||
v8::Local<v8::Value> argv[] = {mate::ConvertToV8(isolate, internal),
|
||||
mate::ConvertToV8(isolate, channel),
|
||||
mate::ConvertToV8(isolate, args),
|
||||
mate::ConvertToV8(isolate, sender_id)};
|
||||
renderer_client_->InvokeIpcCallback(
|
||||
context, "onMessage",
|
||||
std::vector<v8::Local<v8::Value>>(argv, argv + node::arraysize(argv)));
|
||||
}
|
||||
|
||||
private:
|
||||
AtomSandboxedRendererClient* renderer_client_;
|
||||
DISALLOW_COPY_AND_ASSIGN(AtomSandboxedRenderFrameObserver);
|
||||
};
|
||||
void InvokeHiddenCallback(v8::Handle<v8::Context> context,
|
||||
const std::string& hidden_key,
|
||||
const std::string& callback_name) {
|
||||
auto* isolate = context->GetIsolate();
|
||||
auto binding_key = mate::ConvertToV8(isolate, hidden_key)->ToString(isolate);
|
||||
auto private_binding_key = v8::Private::ForApi(isolate, binding_key);
|
||||
auto global_object = context->Global();
|
||||
v8::Local<v8::Value> value;
|
||||
if (!global_object->GetPrivate(context, private_binding_key).ToLocal(&value))
|
||||
return;
|
||||
if (value.IsEmpty() || !value->IsObject())
|
||||
return;
|
||||
auto binding = value->ToObject(isolate);
|
||||
auto callback_key =
|
||||
mate::ConvertToV8(isolate, callback_name)->ToString(isolate);
|
||||
auto callback_value = binding->Get(callback_key);
|
||||
DCHECK(callback_value->IsFunction()); // set by sandboxed_renderer/init.js
|
||||
auto callback = v8::Handle<v8::Function>::Cast(callback_value);
|
||||
ignore_result(callback->Call(context, binding, 0, nullptr));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
|
|
@ -166,7 +151,7 @@ void AtomSandboxedRendererClient::InitializeBindings(
|
|||
|
||||
void AtomSandboxedRendererClient::RenderFrameCreated(
|
||||
content::RenderFrame* render_frame) {
|
||||
new AtomSandboxedRenderFrameObserver(render_frame, this);
|
||||
new AtomRenderFrameObserver(render_frame, this);
|
||||
RendererClientBase::RenderFrameCreated(render_frame);
|
||||
}
|
||||
|
||||
|
|
@ -187,8 +172,7 @@ void AtomSandboxedRendererClient::RunScriptsAtDocumentStart(
|
|||
GetContext(render_frame->GetWebFrame(), isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
|
||||
InvokeIpcCallback(context, "onDocumentStart",
|
||||
std::vector<v8::Local<v8::Value>>());
|
||||
InvokeHiddenCallback(context, kLifecycleKey, "onDocumentStart");
|
||||
}
|
||||
|
||||
void AtomSandboxedRendererClient::RunScriptsAtDocumentEnd(
|
||||
|
|
@ -203,8 +187,7 @@ void AtomSandboxedRendererClient::RunScriptsAtDocumentEnd(
|
|||
GetContext(render_frame->GetWebFrame(), isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
|
||||
InvokeIpcCallback(context, "onDocumentEnd",
|
||||
std::vector<v8::Local<v8::Value>>());
|
||||
InvokeHiddenCallback(context, kLifecycleKey, "onDocumentEnd");
|
||||
}
|
||||
|
||||
void AtomSandboxedRendererClient::DidCreateScriptContext(
|
||||
|
|
@ -303,29 +286,7 @@ void AtomSandboxedRendererClient::WillReleaseScriptContext(
|
|||
auto* isolate = context->GetIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
InvokeIpcCallback(context, "onExit", std::vector<v8::Local<v8::Value>>());
|
||||
}
|
||||
|
||||
void AtomSandboxedRendererClient::InvokeIpcCallback(
|
||||
v8::Handle<v8::Context> context,
|
||||
const std::string& callback_name,
|
||||
std::vector<v8::Handle<v8::Value>> args) {
|
||||
auto* isolate = context->GetIsolate();
|
||||
auto binding_key = mate::ConvertToV8(isolate, kIpcKey)->ToString(isolate);
|
||||
auto private_binding_key = v8::Private::ForApi(isolate, binding_key);
|
||||
auto global_object = context->Global();
|
||||
v8::Local<v8::Value> value;
|
||||
if (!global_object->GetPrivate(context, private_binding_key).ToLocal(&value))
|
||||
return;
|
||||
if (value.IsEmpty() || !value->IsObject())
|
||||
return;
|
||||
auto binding = value->ToObject(isolate);
|
||||
auto callback_key =
|
||||
mate::ConvertToV8(isolate, callback_name)->ToString(isolate);
|
||||
auto callback_value = binding->Get(callback_key);
|
||||
DCHECK(callback_value->IsFunction()); // set by sandboxed_renderer/init.js
|
||||
auto callback = v8::Handle<v8::Function>::Cast(callback_value);
|
||||
ignore_result(callback->Call(context, binding, args.size(), args.data()));
|
||||
InvokeHiddenCallback(context, kLifecycleKey, "onExit");
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
|
|
|
|||
|
|
@ -22,9 +22,6 @@ class AtomSandboxedRendererClient : public RendererClientBase {
|
|||
void InitializeBindings(v8::Local<v8::Object> binding,
|
||||
v8::Local<v8::Context> context,
|
||||
bool is_main_frame);
|
||||
void InvokeIpcCallback(v8::Handle<v8::Context> context,
|
||||
const std::string& callback_name,
|
||||
std::vector<v8::Handle<v8::Value>> args);
|
||||
// atom::RendererClientBase:
|
||||
void DidCreateScriptContext(v8::Handle<v8::Context> context,
|
||||
content::RenderFrame* render_frame) override;
|
||||
|
|
|
|||
167
atom/renderer/electron_api_service_impl.cc
Normal file
167
atom/renderer/electron_api_service_impl.cc
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
// Copyright (c) 2019 Slack Technologies, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "electron/atom/renderer/electron_api_service_impl.h"
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "atom/common/heap_snapshot.h"
|
||||
#include "atom/common/native_mate_converters/value_converter.h"
|
||||
#include "base/macros.h"
|
||||
#include "base/threading/thread_restrictions.h"
|
||||
#include "electron/atom/common/api/event_emitter_caller.h"
|
||||
#include "electron/atom/common/node_includes.h"
|
||||
#include "electron/atom/common/options_switches.h"
|
||||
#include "electron/atom/renderer/atom_render_frame_observer.h"
|
||||
#include "electron/atom/renderer/renderer_client_base.h"
|
||||
#include "mojo/public/cpp/system/platform_handle.h"
|
||||
#include "native_mate/dictionary.h"
|
||||
#include "third_party/blink/public/web/blink.h"
|
||||
#include "third_party/blink/public/web/web_local_frame.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
const char kIpcKey[] = "ipcNative";
|
||||
|
||||
// Gets the private object under kIpcKey
|
||||
v8::Local<v8::Object> GetIpcObject(v8::Local<v8::Context> context) {
|
||||
auto* isolate = context->GetIsolate();
|
||||
auto binding_key = mate::ConvertToV8(isolate, kIpcKey)->ToString(isolate);
|
||||
auto private_binding_key = v8::Private::ForApi(isolate, binding_key);
|
||||
auto global_object = context->Global();
|
||||
auto value =
|
||||
global_object->GetPrivate(context, private_binding_key).ToLocalChecked();
|
||||
DCHECK(!value.IsEmpty() && value->IsObject());
|
||||
return value->ToObject(isolate);
|
||||
}
|
||||
|
||||
void InvokeIpcCallback(v8::Local<v8::Context> context,
|
||||
const std::string& callback_name,
|
||||
std::vector<v8::Local<v8::Value>> args) {
|
||||
TRACE_EVENT0("devtools.timeline", "FunctionCall");
|
||||
auto* isolate = context->GetIsolate();
|
||||
|
||||
auto ipcNative = GetIpcObject(context);
|
||||
|
||||
// Only set up the node::CallbackScope if there's a node environment.
|
||||
// Sandboxed renderers don't have a node environment.
|
||||
node::Environment* env = node::Environment::GetCurrent(context);
|
||||
std::unique_ptr<node::CallbackScope> callback_scope;
|
||||
if (env) {
|
||||
callback_scope.reset(new node::CallbackScope(isolate, ipcNative, {0, 0}));
|
||||
}
|
||||
|
||||
auto callback_key =
|
||||
mate::ConvertToV8(isolate, callback_name)->ToString(isolate);
|
||||
auto callback_value = ipcNative->Get(callback_key);
|
||||
DCHECK(callback_value->IsFunction()); // set by init.ts
|
||||
auto callback = v8::Local<v8::Function>::Cast(callback_value);
|
||||
ignore_result(callback->Call(context, ipcNative, args.size(), args.data()));
|
||||
}
|
||||
|
||||
void EmitIPCEvent(v8::Local<v8::Context> context,
|
||||
bool internal,
|
||||
const std::string& channel,
|
||||
const std::vector<base::Value>& args,
|
||||
int32_t sender_id) {
|
||||
auto* isolate = context->GetIsolate();
|
||||
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::MicrotasksScope script_scope(isolate,
|
||||
v8::MicrotasksScope::kRunMicrotasks);
|
||||
|
||||
std::vector<v8::Local<v8::Value>> argv = {
|
||||
mate::ConvertToV8(isolate, internal), mate::ConvertToV8(isolate, channel),
|
||||
mate::ConvertToV8(isolate, args), mate::ConvertToV8(isolate, sender_id)};
|
||||
|
||||
InvokeIpcCallback(context, "onMessage", argv);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
ElectronApiServiceImpl::~ElectronApiServiceImpl() = default;
|
||||
|
||||
ElectronApiServiceImpl::ElectronApiServiceImpl(
|
||||
content::RenderFrame* render_frame,
|
||||
RendererClientBase* renderer_client,
|
||||
mojom::ElectronRendererAssociatedRequest request)
|
||||
: content::RenderFrameObserver(render_frame),
|
||||
binding_(this),
|
||||
render_frame_(render_frame),
|
||||
renderer_client_(renderer_client) {
|
||||
binding_.Bind(std::move(request));
|
||||
binding_.set_connection_error_handler(base::BindOnce(
|
||||
&ElectronApiServiceImpl::OnDestruct, base::Unretained(this)));
|
||||
}
|
||||
|
||||
// static
|
||||
void ElectronApiServiceImpl::CreateMojoService(
|
||||
content::RenderFrame* render_frame,
|
||||
RendererClientBase* renderer_client,
|
||||
mojom::ElectronRendererAssociatedRequest request) {
|
||||
DCHECK(render_frame);
|
||||
|
||||
// Owns itself. Will be deleted when the render frame is destroyed.
|
||||
new ElectronApiServiceImpl(render_frame, renderer_client, std::move(request));
|
||||
}
|
||||
|
||||
void ElectronApiServiceImpl::OnDestruct() {
|
||||
delete this;
|
||||
}
|
||||
|
||||
void ElectronApiServiceImpl::Message(bool internal,
|
||||
bool send_to_all,
|
||||
const std::string& channel,
|
||||
base::Value arguments,
|
||||
int32_t sender_id) {
|
||||
blink::WebLocalFrame* frame = render_frame_->GetWebFrame();
|
||||
if (!frame)
|
||||
return;
|
||||
|
||||
v8::Isolate* isolate = blink::MainThreadIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
|
||||
v8::Local<v8::Context> context = renderer_client_->GetContext(frame, isolate);
|
||||
|
||||
EmitIPCEvent(context, internal, channel, arguments.GetList(), sender_id);
|
||||
|
||||
// Also send the message to all sub-frames.
|
||||
// TODO(MarshallOfSound): Completely move this logic to the main process
|
||||
if (send_to_all) {
|
||||
for (blink::WebFrame* child = frame->FirstChild(); child;
|
||||
child = child->NextSibling())
|
||||
if (child->IsWebLocalFrame()) {
|
||||
v8::Local<v8::Context> child_context =
|
||||
renderer_client_->GetContext(child->ToWebLocalFrame(), isolate);
|
||||
EmitIPCEvent(child_context, internal, channel, arguments.GetList(),
|
||||
sender_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ElectronApiServiceImpl::TakeHeapSnapshot(
|
||||
mojo::ScopedHandle file,
|
||||
TakeHeapSnapshotCallback callback) {
|
||||
base::ThreadRestrictions::ScopedAllowIO allow_io;
|
||||
|
||||
base::PlatformFile platform_file;
|
||||
if (mojo::UnwrapPlatformFile(std::move(file), &platform_file) !=
|
||||
MOJO_RESULT_OK) {
|
||||
LOG(ERROR) << "Unable to get the file handle from mojo.";
|
||||
std::move(callback).Run(false);
|
||||
return;
|
||||
}
|
||||
base::File base_file(platform_file);
|
||||
|
||||
bool success = atom::TakeHeapSnapshot(blink::MainThreadIsolate(), &base_file);
|
||||
|
||||
std::move(callback).Run(success);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
55
atom/renderer/electron_api_service_impl.h
Normal file
55
atom/renderer/electron_api_service_impl.h
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
// Copyright (c) 2019 Slack Technologies, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_RENDERER_ELECTRON_API_SERVICE_IMPL_H_
|
||||
#define ATOM_RENDERER_ELECTRON_API_SERVICE_IMPL_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "content/public/renderer/render_frame.h"
|
||||
#include "content/public/renderer/render_frame_observer.h"
|
||||
#include "electron/atom/common/api/api.mojom.h"
|
||||
#include "mojo/public/cpp/bindings/associated_binding.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class RendererClientBase;
|
||||
|
||||
class ElectronApiServiceImpl : public mojom::ElectronRenderer,
|
||||
public content::RenderFrameObserver {
|
||||
public:
|
||||
static void CreateMojoService(
|
||||
content::RenderFrame* render_frame,
|
||||
RendererClientBase* renderer_client,
|
||||
mojom::ElectronRendererAssociatedRequest request);
|
||||
|
||||
void Message(bool internal,
|
||||
bool send_to_all,
|
||||
const std::string& channel,
|
||||
base::Value arguments,
|
||||
int32_t sender_id) override;
|
||||
|
||||
void TakeHeapSnapshot(mojo::ScopedHandle file,
|
||||
TakeHeapSnapshotCallback callback) override;
|
||||
|
||||
private:
|
||||
~ElectronApiServiceImpl() override;
|
||||
ElectronApiServiceImpl(content::RenderFrame* render_frame,
|
||||
RendererClientBase* renderer_client,
|
||||
mojom::ElectronRendererAssociatedRequest request);
|
||||
|
||||
// RenderFrameObserver implementation.
|
||||
void OnDestruct() override;
|
||||
|
||||
mojo::AssociatedBinding<mojom::ElectronRenderer> binding_;
|
||||
|
||||
content::RenderFrame* render_frame_;
|
||||
RendererClientBase* renderer_client_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(ElectronApiServiceImpl);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_RENDERER_ELECTRON_API_SERVICE_IMPL_H_
|
||||
|
|
@ -15,6 +15,7 @@
|
|||
#include "atom/renderer/atom_render_frame_observer.h"
|
||||
#include "atom/renderer/atom_render_view_observer.h"
|
||||
#include "atom/renderer/content_settings_observer.h"
|
||||
#include "atom/renderer/electron_api_service_impl.h"
|
||||
#include "atom/renderer/preferences_manager.h"
|
||||
#include "base/command_line.h"
|
||||
#include "base/strings/string_split.h"
|
||||
|
|
@ -26,6 +27,7 @@
|
|||
#include "electron/buildflags/buildflags.h"
|
||||
#include "native_mate/dictionary.h"
|
||||
#include "printing/buildflags/buildflags.h"
|
||||
#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
|
||||
#include "third_party/blink/public/web/blink.h"
|
||||
#include "third_party/blink/public/web/web_custom_element.h" // NOLINT(build/include_alpha)
|
||||
#include "third_party/blink/public/web/web_frame_widget.h"
|
||||
|
|
@ -215,6 +217,18 @@ void RendererClientBase::RenderFrameCreated(
|
|||
render_frame, std::make_unique<atom::PrintRenderFrameHelperDelegate>());
|
||||
#endif
|
||||
|
||||
// TODO(nornagon): it might be possible for an IPC message sent to this
|
||||
// service to trigger v8 context creation before the page has begun loading.
|
||||
// However, it's unclear whether such a timing is possible to trigger, and we
|
||||
// don't have any test to confirm it. Add a test that confirms that a
|
||||
// main->renderer IPC can't cause the preload script to be executed twice. If
|
||||
// it is possible to trigger the preload script before the document is ready
|
||||
// through this interface, we should delay adding it to the registry until
|
||||
// the document is ready.
|
||||
render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
|
||||
base::BindRepeating(&ElectronApiServiceImpl::CreateMojoService,
|
||||
render_frame, this));
|
||||
|
||||
#if BUILDFLAG(ENABLE_PDF_VIEWER)
|
||||
// Allow access to file scheme from pdf viewer.
|
||||
blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue