mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

refactor: dispatch IPC messages from Session (#45452)

Browse source 
* refactor: dispatch IPC messages from Session

* refactor: move MessageHost to Session
This commit is contained in:
Sam Maddock 2025-02-17 16:36:28 -05:00 • committed by GitHub
parent e9ba5876d1
commit c0422d7cc9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 250 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lib/browser/api/session.ts
View file

@ -23,7 +23,7 @@ systemPickerVideoSource.name = '';
Object.freeze(systemPickerVideoSource);
Session.prototype._init = function () {
addIpcDispatchListeners(this, this.serviceWorkers);
addIpcDispatchListeners(this);
};
Session.prototype.fetch = function (input: RequestInfo, init?: RequestInit) {

111
lib/browser/api/web-contents.ts
View file

@ -1,13 +1,11 @@
import { openGuestWindow, makeWebPreferences, parseContentTypeFormat } from '@electron/internal/browser/guest-window-manager';
import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl';
import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
import { MessagePortMain } from '@electron/internal/browser/message-port-main';
import { parseFeatures } from '@electron/internal/browser/parse-features-string';
import * as deprecate from '@electron/internal/common/deprecate';
import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
import { app, ipcMain, session, webFrameMain, dialog } from 'electron/main';
import { app, session, webFrameMain, dialog } from 'electron/main';
import type { BrowserWindowConstructorOptions, MessageBoxOptions, NavigationEntry } from 'electron/main';
import * as path from 'path';
@ -18,8 +16,6 @@ import * as url from 'url';
// eslint-disable-next-line no-unused-expressions
session;
const webFrameMainBinding = process._linkedBinding('electron_browser_web_frame_main');
let nextId = 0;
const getNextId = function () {
return ++nextId;
@ -480,24 +476,6 @@ WebContents.prototype._callWindowOpenHandler = function (event: Electron.Event,
}
};
const addReplyToEvent = (event: Electron.IpcMainEvent) => {
const { processId, frameId } = event;
event.reply = (channel: string, ...args: any[]) => {
event.sender.sendToFrame([processId, frameId], channel, ...args);
};
};
const addSenderToEvent = (event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent, sender: Electron.WebContents) => {
event.sender = sender;
};
const addReturnValueToEvent = (event: Electron.IpcMainEvent) => {
Object.defineProperty(event, 'returnValue', {
set: (value) => event._replyChannel.sendReply(value),
get: () => {}
});
};
const commandLine = process._linkedBinding('electron_common_command_line');
const environment = process._linkedBinding('electron_common_environment');
@ -577,28 +555,6 @@ WebContents.prototype._init = function () {
enumerable: true
});
/**
* Cached IPC emitters sorted by dispatch priority.
* Caching is used to avoid frequent array allocations.
*
* 0: WebFrameMain ipc
* 1: WebContents ipc
* 2: ipcMain
*/
const cachedIpcEmitters: (ElectronInternal.IpcMainInternal | undefined)[] = [undefined, ipc, ipcMain];
// Get list of relevant IPC emitters for dispatch.
const getIpcEmittersForEvent = (event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent): (ElectronInternal.IpcMainInternal | undefined)[] => {
// Lookup by FrameTreeNode ID to ensure IPCs received after a frame swap are
// always received. This occurs when a RenderFrame sends an IPC while it's
// unloading and its internal state is pending deletion.
const { frameTreeNodeId } = event;
const webFrameByFtn = frameTreeNodeId ? webFrameMainBinding._fromFtnIdIfExists(frameTreeNodeId) : undefined;
cachedIpcEmitters[0] = webFrameByFtn?.ipc;
return cachedIpcEmitters;
};
// Add navigationHistory property which handles session history,
// maintaining a list of navigation entries for backward and forward navigation.
Object.defineProperty(this, 'navigationHistory', {
@ -641,71 +597,6 @@ WebContents.prototype._init = function () {
enumerable: true
});
// Dispatch IPC messages to the ipc module.
this.on('-ipc-message', function (this: Electron.WebContents, event, internal, channel, args) {
addSenderToEvent(event, this);
if (internal) {
ipcMainInternal.emit(channel, event, ...args);
} else {
addReplyToEvent(event);
this.emit('ipc-message', event, channel, ...args);
for (const ipcEmitter of getIpcEmittersForEvent(event)) {
ipcEmitter?.emit(channel, event, ...args);
}
}
});
this.on('-ipc-invoke', async function (this: Electron.WebContents, event, internal, channel, args) {
addSenderToEvent(event, this);
const replyWithResult = (result: any) => event._replyChannel.sendReply({ result });
const replyWithError = (error: Error) => {
console.error(`Error occurred in handler for '${channel}':`, error);
event._replyChannel.sendReply({ error: error.toString() });
};
const targets: (ElectronInternal.IpcMainInternal | undefined)[] = internal ? [ipcMainInternal] : getIpcEmittersForEvent(event);
const target = targets.find(target => (target as any)?._invokeHandlers.has(channel));
if (target) {
const handler = (target as any)._invokeHandlers.get(channel);
try {
replyWithResult(await Promise.resolve(handler(event, ...args)));
} catch (err) {
replyWithError(err as Error);
}
} else {
replyWithError(new Error(`No handler registered for '${channel}'`));
}
});
this.on('-ipc-message-sync', function (this: Electron.WebContents, event, internal, channel, args) {
addSenderToEvent(event, this);
addReturnValueToEvent(event);
if (internal) {
ipcMainInternal.emit(channel, event, ...args);
} else {
addReplyToEvent(event);
const ipcEmitters = getIpcEmittersForEvent(event);
if (
this.listenerCount('ipc-message-sync') === 0 &&
ipcEmitters.every(emitter => !emitter || emitter.listenerCount(channel) === 0)
) {
console.warn(`WebContents #${this.id} called ipcRenderer.sendSync() with '${channel}' channel without listeners.`);
}
this.emit('ipc-message-sync', event, channel, ...args);
for (const ipcEmitter of ipcEmitters) {
ipcEmitter?.emit(channel, event, ...args);
}
}
});
this.on('-ipc-ports', function (this: Electron.WebContents, event: Electron.IpcMainEvent, internal: boolean, channel: string, message: any, ports: any[]) {
addSenderToEvent(event, this);
event.ports = ports.map(p => new MessagePortMain(p));
const ipcEmitters = getIpcEmittersForEvent(event);
for (const ipcEmitter of ipcEmitters) {
ipcEmitter?.emit(channel, event, message);
}
});
this.on('render-process-gone', (event, details) => {
app.emit('render-process-gone', event, this, details);

2
lib/browser/guest-view-manager.ts
View file

@ -155,7 +155,7 @@ const createGuest = function (embedder: Electron.WebContents, embedderFrameId: n
}
// Dispatch guest's IPC messages to embedder.
guest.on('ipc-message-host' as any, function (event: Electron.IpcMainEvent, channel: string, args: any[]) {
guest.on('-ipc-message-host' as any, function (event: Electron.IpcMainEvent, channel: string, args: any[]) {
sendToEmbedder(IPC_MESSAGES.GUEST_VIEW_INTERNAL_DISPATCH_EVENT, 'ipc-message', {
frameId: [event.processId, event.frameId],
channel,

78
lib/browser/ipc-dispatch.ts
View file

@ -2,8 +2,17 @@ import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
import { MessagePortMain } from '@electron/internal/browser/message-port-main';
import type { ServiceWorkerMain } from 'electron/main';
import { ipcMain } from 'electron/main';
const v8Util = process._linkedBinding('electron_common_v8_util');
const webFrameMainBinding = process._linkedBinding('electron_browser_web_frame_main');
const addReplyToEvent = (event: Electron.IpcMainEvent) => {
const { processId, frameId } = event;
event.reply = (channel: string, ...args: any[]) => {
event.sender.sendToFrame([processId, frameId], channel, ...args);
};
};
const addReturnValueToEvent = (event: Electron.IpcMainEvent | Electron.IpcMainServiceWorkerEvent) => {
Object.defineProperty(event, 'returnValue', {
@ -12,26 +21,52 @@ const addReturnValueToEvent = (event: Electron.IpcMainEvent | Electron.IpcMainSe
});
};
/**
* Listens for IPC dispatch events on `api`.
*
* NOTE: Currently this only supports dispatching IPCs for ServiceWorkerMain.
*/
export function addIpcDispatchListeners (api: NodeJS.EventEmitter, serviceWorkers: Electron.ServiceWorkers) {
const getServiceWorkerFromEvent = (event: Electron.IpcMainServiceWorkerEvent | Electron.IpcMainServiceWorkerInvokeEvent): ServiceWorkerMain | undefined => {
return serviceWorkers._getWorkerFromVersionIDIfExists(event.versionId);
return event.session.serviceWorkers._getWorkerFromVersionIDIfExists(event.versionId);
};
const addServiceWorkerPropertyToEvent = (event: Electron.IpcMainServiceWorkerEvent | Electron.IpcMainServiceWorkerInvokeEvent) => {
Object.defineProperty(event, 'serviceWorker', {
get: () => serviceWorkers.getWorkerFromVersionID(event.versionId)
get: () => event.session.serviceWorkers.getWorkerFromVersionID(event.versionId)
});
};
/**
* Cached IPC emitters sorted by dispatch priority.
* Caching is used to avoid frequent array allocations.
*/
const cachedIpcEmitters: (ElectronInternal.IpcMainInternal | undefined)[] = [
undefined, // WebFrameMain ipc
undefined, // WebContents ipc
ipcMain
];
// Get list of relevant IPC emitters for dispatch.
const getIpcEmittersForFrameEvent = (event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent): (ElectronInternal.IpcMainInternal | undefined)[] => {
// Lookup by FrameTreeNode ID to ensure IPCs received after a frame swap are
// always received. This occurs when a RenderFrame sends an IPC while it's
// unloading and its internal state is pending deletion.
const { frameTreeNodeId } = event;
const webFrameByFtn = frameTreeNodeId ? webFrameMainBinding._fromFtnIdIfExists(frameTreeNodeId) : undefined;
cachedIpcEmitters[0] = webFrameByFtn?.ipc;
cachedIpcEmitters[1] = event.sender.ipc;
return cachedIpcEmitters;
};
/**
* Listens for IPC dispatch events on `api`.
*/
export function addIpcDispatchListeners (api: NodeJS.EventEmitter) {
api.on('-ipc-message' as any, function (event: Electron.IpcMainEvent | Electron.IpcMainServiceWorkerEvent, channel: string, args: any[]) {
const internal = v8Util.getHiddenValue<boolean>(event, 'internal');
if (internal) {
ipcMainInternal.emit(channel, event, ...args);
} else if (event.type === 'frame') {
addReplyToEvent(event);
event.sender.emit('ipc-message', event, channel, ...args);
for (const ipcEmitter of getIpcEmittersForFrameEvent(event)) {
ipcEmitter?.emit(channel, event, ...args);
}
} else if (event.type === 'service-worker') {
addServiceWorkerPropertyToEvent(event);
getServiceWorkerFromEvent(event)?.ipc.emit(channel, event, ...args);
@ -51,6 +86,8 @@ export function addIpcDispatchListeners (api: NodeJS.EventEmitter, serviceWorker
if (internal) {
targets.push(ipcMainInternal);
} else if (event.type === 'frame') {
targets.push(...getIpcEmittersForFrameEvent(event));
} else if (event.type === 'service-worker') {
addServiceWorkerPropertyToEvent(event);
const workerIpc = getServiceWorkerFromEvent(event)?.ipc;
@ -75,15 +112,38 @@ export function addIpcDispatchListeners (api: NodeJS.EventEmitter, serviceWorker
addReturnValueToEvent(event);
if (internal) {
ipcMainInternal.emit(channel, event, ...args);
} else if (event.type === 'frame') {
addReplyToEvent(event);
const webContents = event.sender;
const ipcEmitters = getIpcEmittersForFrameEvent(event);
if (
webContents.listenerCount('ipc-message-sync') === 0 &&
ipcEmitters.every(emitter => !emitter || emitter.listenerCount(channel) === 0)
) {
console.warn(`WebContents #${webContents.id} called ipcRenderer.sendSync() with '${channel}' channel without listeners.`);
}
webContents.emit('ipc-message-sync', event, channel, ...args);
for (const ipcEmitter of ipcEmitters) {
ipcEmitter?.emit(channel, event, ...args);
}
} else if (event.type === 'service-worker') {
addServiceWorkerPropertyToEvent(event);
getServiceWorkerFromEvent(event)?.ipc.emit(channel, event, ...args);
}
} as any);
api.on('-ipc-message-host', function (event: Electron.IpcMainEvent, channel: string, args: any[]) {
event.sender.emit('-ipc-message-host', event, channel, args);
});
api.on('-ipc-ports' as any, function (event: Electron.IpcMainEvent | Electron.IpcMainServiceWorkerEvent, channel: string, message: any, ports: any[]) {
event.ports = ports.map(p => new MessagePortMain(p));
if (event.type === 'service-worker') {
if (event.type === 'frame') {
const ipcEmitters = getIpcEmittersForFrameEvent(event);
for (const ipcEmitter of ipcEmitters) {
ipcEmitter?.emit(channel, event, message);
}
} if (event.type === 'service-worker') {
addServiceWorkerPropertyToEvent(event);
getServiceWorkerFromEvent(event)?.ipc.emit(channel, event, message);
}

91
shell/browser/api/electron_api_web_contents.cc
View file

@ -2005,30 +2005,6 @@ bool WebContents::EmitNavigationEvent(
return event->GetDefaultPrevented();
}
void WebContents::Message(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
content::RenderFrameHost* render_frame_host) {
TRACE_EVENT1("electron", "WebContents::Message", "channel", channel);
// webContents.emit('-ipc-message', new Event(), internal, channel,
// arguments);
EmitWithSender("-ipc-message", render_frame_host,
electron::mojom::ElectronApiIPC::InvokeCallback(), internal,
channel, std::move(arguments));
}
void WebContents::Invoke(
bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::InvokeCallback callback,
content::RenderFrameHost* render_frame_host) {
TRACE_EVENT1("electron", "WebContents::Invoke", "channel", channel);
// webContents.emit('-ipc-invoke', new Event(), internal, channel, arguments);
EmitWithSender("-ipc-invoke", render_frame_host, std::move(callback),
internal, channel, std::move(arguments));
}
void WebContents::OnFirstNonEmptyLayout(
content::RenderFrameHost* render_frame_host) {
if (render_frame_host == web_contents()->GetPrimaryMainFrame()) {
@ -2036,73 +2012,6 @@ void WebContents::OnFirstNonEmptyLayout(
}
}
gin::Handle<gin_helper::internal::Event> WebContents::MakeEventWithSender(
v8::Isolate* isolate,
content::RenderFrameHost* frame,
electron::mojom::ElectronApiIPC::InvokeCallback callback) {
v8::Local<v8::Object> wrapper;
if (!GetWrapper(isolate).ToLocal(&wrapper)) {
if (callback) {
// We must always invoke the callback if present.
gin_helper::internal::ReplyChannel::Create(isolate, std::move(callback))
->SendError("WebContents was destroyed");
}
return {};
}
gin::Handle<gin_helper::internal::Event> event =
gin_helper::internal::Event::New(isolate);
gin_helper::Dictionary dict(isolate, event.ToV8().As<v8::Object>());
dict.Set("type", "frame");
if (callback)
dict.Set("_replyChannel", gin_helper::internal::ReplyChannel::Create(
isolate, std::move(callback)));
if (frame) {
dict.SetGetter("senderFrame", frame);
dict.Set("frameId", frame->GetRoutingID());
dict.Set("processId", frame->GetProcess()->GetID().GetUnsafeValue());
dict.Set("frameTreeNodeId", frame->GetFrameTreeNodeId());
}
return event;
}
void WebContents::ReceivePostMessage(
const std::string& channel,
blink::TransferableMessage message,
content::RenderFrameHost* render_frame_host) {
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto wrapped_ports =
MessagePort::EntanglePorts(isolate, std::move(message.ports));
v8::Local<v8::Value> message_value =
electron::DeserializeV8Value(isolate, message);
EmitWithSender("-ipc-ports", render_frame_host,
electron::mojom::ElectronApiIPC::InvokeCallback(), false,
channel, message_value, std::move(wrapped_ports));
}
void WebContents::MessageSync(
bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::MessageSyncCallback callback,
content::RenderFrameHost* render_frame_host) {
TRACE_EVENT1("electron", "WebContents::MessageSync", "channel", channel);
// webContents.emit('-ipc-message-sync', new Event(sender, message), internal,
// channel, arguments);
EmitWithSender("-ipc-message-sync", render_frame_host, std::move(callback),
internal, channel, std::move(arguments));
}
void WebContents::MessageHost(const std::string& channel,
blink::CloneableMessage arguments,
content::RenderFrameHost* render_frame_host) {
TRACE_EVENT1("electron", "WebContents::MessageHost", "channel", channel);
// webContents.emit('ipc-message-host', new Event(), channel, args);
EmitWithSender("ipc-message-host", render_frame_host,
electron::mojom::ElectronApiIPC::InvokeCallback(), channel,
std::move(arguments));
}
void WebContents::DraggableRegionsChanged(
const std::vector<blink::mojom::DraggableRegionPtr>& regions,
content::WebContents* contents) {

46
shell/browser/api/electron_api_web_contents.h
View file

@ -393,29 +393,6 @@ class WebContents final : public ExclusiveAccessContext,
bool EmitNavigationEvent(const std::string& event,
content::NavigationHandle* navigation_handle);
// this.emit(name, new Event(sender, message), args...);
template <typename... Args>
bool EmitWithSender(const std::string_view name,
content::RenderFrameHost* frame,
electron::mojom::ElectronApiIPC::InvokeCallback callback,
Args&&... args) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
gin::Handle<gin_helper::internal::Event> event =
MakeEventWithSender(isolate, frame, std::move(callback));
if (event.IsEmpty())
return false;
EmitWithoutEvent(name, event, std::forward<Args>(args)...);
return event->GetDefaultPrevented();
}
gin::Handle<gin_helper::internal::Event> MakeEventWithSender(
v8::Isolate* isolate,
content::RenderFrameHost* frame,
electron::mojom::ElectronApiIPC::InvokeCallback callback);
WebContents* embedder() { return embedder_; }
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
@ -448,29 +425,6 @@ class WebContents final : public ExclusiveAccessContext,
fullscreen_frame_ = rfh;
}
// mojom::ElectronApiIPC
void Message(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
content::RenderFrameHost* render_frame_host);
void Invoke(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::InvokeCallback callback,
content::RenderFrameHost* render_frame_host);
void ReceivePostMessage(const std::string& channel,
blink::TransferableMessage message,
content::RenderFrameHost* render_frame_host);
void MessageSync(
bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::MessageSyncCallback callback,
content::RenderFrameHost* render_frame_host);
void MessageHost(const std::string& channel,
blink::CloneableMessage arguments,
content::RenderFrameHost* render_frame_host);
// mojom::ElectronWebContentsUtility
void OnFirstNonEmptyLayout(content::RenderFrameHost* render_frame_host);
void SetTemporaryZoomLevel(double level);

35
shell/browser/api/ipc_dispatcher.h
View file

@ -35,15 +35,8 @@ class IpcDispatcher {
void Invoke(gin::Handle<gin_helper::internal::Event>& event,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::InvokeCallback callback) {
TRACE_EVENT1("electron", "IpcHelper::Invoke", "channel", channel);
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
gin_helper::Dictionary dict(isolate, event.ToV8().As<v8::Object>());
dict.Set("_replyChannel", gin_helper::internal::ReplyChannel::Create(
isolate, std::move(callback)));
blink::CloneableMessage arguments) {
TRACE_EVENT1("electron", "IpcDispatcher::Invoke", "channel", channel);
emitter()->EmitWithoutEvent("-ipc-invoke", event, channel,
std::move(arguments));
}
@ -51,6 +44,8 @@ class IpcDispatcher {
void ReceivePostMessage(gin::Handle<gin_helper::internal::Event>& event,
const std::string& channel,
blink::TransferableMessage message) {
TRACE_EVENT1("electron", "IpcDispatcher::ReceivePostMessage", "channel",
channel);
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto wrapped_ports =
@ -61,22 +56,22 @@ class IpcDispatcher {
std::move(wrapped_ports));
}
void MessageSync(
gin::Handle<gin_helper::internal::Event>& event,
void MessageSync(gin::Handle<gin_helper::internal::Event>& event,
const std::string& channel,
blink::CloneableMessage arguments,
electron::mojom::ElectronApiIPC::MessageSyncCallback callback) {
TRACE_EVENT1("electron", "IpcHelper::MessageSync", "channel", channel);
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
gin_helper::Dictionary dict(isolate, event.ToV8().As<v8::Object>());
dict.Set("_replyChannel", gin_helper::internal::ReplyChannel::Create(
isolate, std::move(callback)));
blink::CloneableMessage arguments) {
TRACE_EVENT1("electron", "IpcDispatcher::MessageSync", "channel", channel);
emitter()->EmitWithoutEvent("-ipc-message-sync", event, channel,
std::move(arguments));
}
void MessageHost(gin::Handle<gin_helper::internal::Event>& event,
const std::string& channel,
blink::CloneableMessage arguments) {
TRACE_EVENT1("electron", "IpcDispatcher::MessageHost", "channel", channel);
emitter()->EmitWithoutEvent("-ipc-message-host", event, channel,
std::move(arguments));
}
private:
inline T* emitter() {
// T must inherit from gin_helper::EventEmitterMixin<T>

126
shell/browser/electron_api_ipc_handler_impl.cc
View file

@ -8,7 +8,12 @@
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "gin/handle.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "shell/browser/api/electron_api_session.h"
#include "shell/common/gin_converters/content_converter.h"
#include "shell/common/gin_converters/frame_converter.h"
#include "shell/common/gin_helper/event.h"
namespace electron {
ElectronApiIPCHandlerImpl::ElectronApiIPCHandlerImpl(
@ -38,57 +43,128 @@ void ElectronApiIPCHandlerImpl::OnConnectionError() {
void ElectronApiIPCHandlerImpl::Message(bool internal,
const std::string& channel,
blink::CloneableMessage arguments) {
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (api_web_contents) {
api_web_contents->Message(internal, channel, std::move(arguments),
GetRenderFrameHost());
}
auto* session = GetSession();
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto event = MakeIPCEvent(isolate, session, internal);
if (event.IsEmpty())
return;
session->Message(event, channel, std::move(arguments));
}
void ElectronApiIPCHandlerImpl::Invoke(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
InvokeCallback callback) {
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (api_web_contents) {
api_web_contents->Invoke(internal, channel, std::move(arguments),
std::move(callback), GetRenderFrameHost());
}
auto* session = GetSession();
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto event = MakeIPCEvent(isolate, session, internal, std::move(callback));
if (event.IsEmpty())
return;
session->Invoke(event, channel, std::move(arguments));
}
void ElectronApiIPCHandlerImpl::ReceivePostMessage(
const std::string& channel,
blink::TransferableMessage message) {
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (api_web_contents) {
api_web_contents->ReceivePostMessage(channel, std::move(message),
GetRenderFrameHost());
}
auto* session = GetSession();
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto event = MakeIPCEvent(isolate, session, false);
if (event.IsEmpty())
return;
session->ReceivePostMessage(event, channel, std::move(message));
}
void ElectronApiIPCHandlerImpl::MessageSync(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
MessageSyncCallback callback) {
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (api_web_contents) {
api_web_contents->MessageSync(internal, channel, std::move(arguments),
std::move(callback), GetRenderFrameHost());
}
auto* session = GetSession();
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto event = MakeIPCEvent(isolate, session, internal, std::move(callback));
if (event.IsEmpty())
return;
session->MessageSync(event, channel, std::move(arguments));
}
void ElectronApiIPCHandlerImpl::MessageHost(const std::string& channel,
blink::CloneableMessage arguments) {
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (api_web_contents) {
api_web_contents->MessageHost(channel, std::move(arguments),
GetRenderFrameHost());
}
auto* session = GetSession();
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
auto event = MakeIPCEvent(isolate, session, false);
if (event.IsEmpty())
return;
session->MessageHost(event, channel, std::move(arguments));
}
content::RenderFrameHost* ElectronApiIPCHandlerImpl::GetRenderFrameHost() {
return content::RenderFrameHost::FromID(render_frame_host_id_);
}
api::Session* ElectronApiIPCHandlerImpl::GetSession() {
auto* rfh = GetRenderFrameHost();
return rfh ? api::Session::FromBrowserContext(rfh->GetBrowserContext())
: nullptr;
}
gin::Handle<gin_helper::internal::Event>
ElectronApiIPCHandlerImpl::MakeIPCEvent(
v8::Isolate* isolate,
api::Session* session,
bool internal,
electron::mojom::ElectronApiIPC::InvokeCallback callback) {
if (!session) {
if (callback) {
// We must always invoke the callback if present.
gin_helper::internal::ReplyChannel::Create(isolate, std::move(callback))
->SendError("Session does not exist");
}
return {};
}
api::WebContents* api_web_contents = api::WebContents::From(web_contents());
if (!api_web_contents) {
if (callback) {
// We must always invoke the callback if present.
gin_helper::internal::ReplyChannel::Create(isolate, std::move(callback))
->SendError("WebContents does not exist");
}
return {};
}
v8::Local<v8::Object> wrapper;
if (!api_web_contents->GetWrapper(isolate).ToLocal(&wrapper)) {
if (callback) {
// We must always invoke the callback if present.
gin_helper::internal::ReplyChannel::Create(isolate, std::move(callback))
->SendError("WebContents was destroyed");
}
return {};
}
content::RenderFrameHost* frame = GetRenderFrameHost();
gin::Handle<gin_helper::internal::Event> event =
gin_helper::internal::Event::New(isolate);
gin_helper::Dictionary dict(isolate, event.ToV8().As<v8::Object>());
dict.Set("type", "frame");
dict.Set("sender", web_contents());
if (internal)
dict.SetHidden("internal", internal);
if (callback)
dict.Set("_replyChannel", gin_helper::internal::ReplyChannel::Create(
isolate, std::move(callback)));
if (frame) {
dict.SetGetter("senderFrame", frame);
dict.Set("frameId", frame->GetRoutingID());
dict.Set("processId", frame->GetProcess()->GetID().GetUnsafeValue());
dict.Set("frameTreeNodeId", frame->GetFrameTreeNodeId());
}
return event;
}
// static
void ElectronApiIPCHandlerImpl::Create(
content::RenderFrameHost* frame_host,

8
shell/browser/electron_api_ipc_handler_impl.h
View file

@ -65,6 +65,14 @@ class ElectronApiIPCHandlerImpl : public mojom::ElectronApiIPC,
void OnConnectionError();
content::RenderFrameHost* GetRenderFrameHost();
api::Session* GetSession();
gin::Handle<gin_helper::internal::Event> MakeIPCEvent(
v8::Isolate* isolate,
api::Session* session,
bool internal,
electron::mojom::ElectronApiIPC::InvokeCallback callback =
electron::mojom::ElectronApiIPC::InvokeCallback());
content::GlobalRenderFrameHostId render_frame_host_id_;

54
shell/browser/electron_api_sw_ipc_handler_impl.cc
View file

@ -71,55 +71,50 @@ void ElectronApiSWIPCHandlerImpl::Message(bool internal,
const std::string& channel,
blink::CloneableMessage arguments) {
auto* session = GetSession();
if (session) {
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
gin::Handle<gin_helper::internal::Event> event =
MakeIPCEvent(isolate, internal);
auto event = MakeIPCEvent(isolate, session, internal);
if (event.IsEmpty())
return;
session->Message(event, channel, std::move(arguments));
}
}
void ElectronApiSWIPCHandlerImpl::Invoke(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
InvokeCallback callback) {
auto* session = GetSession();
if (session) {
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
gin::Handle<gin_helper::internal::Event> event =
MakeIPCEvent(isolate, internal);
session->Invoke(event, channel, std::move(arguments), std::move(callback));
}
auto event = MakeIPCEvent(isolate, session, internal, std::move(callback));
if (event.IsEmpty())
return;
session->Invoke(event, channel, std::move(arguments));
}
void ElectronApiSWIPCHandlerImpl::ReceivePostMessage(
const std::string& channel,
blink::TransferableMessage message) {
auto* session = GetSession();
if (session) {
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
gin::Handle<gin_helper::internal::Event> event =
MakeIPCEvent(isolate, false);
auto event = MakeIPCEvent(isolate, session, false);
if (event.IsEmpty())
return;
session->ReceivePostMessage(event, channel, std::move(message));
}
}
void ElectronApiSWIPCHandlerImpl::MessageSync(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
MessageSyncCallback callback) {
auto* session = GetSession();
if (session) {
v8::Isolate* isolate = electron::JavascriptEnvironment::GetIsolate();
v8::HandleScope handle_scope(isolate);
gin::Handle<gin_helper::internal::Event> event =
MakeIPCEvent(isolate, internal);
session->MessageSync(event, channel, std::move(arguments),
std::move(callback));
}
auto event = MakeIPCEvent(isolate, session, internal, std::move(callback));
if (event.IsEmpty())
return;
session->MessageSync(event, channel, std::move(arguments));
}
void ElectronApiSWIPCHandlerImpl::MessageHost(
@ -139,7 +134,20 @@ api::Session* ElectronApiSWIPCHandlerImpl::GetSession() {
}
gin::Handle<gin_helper::internal::Event>
ElectronApiSWIPCHandlerImpl::MakeIPCEvent(v8::Isolate* isolate, bool internal) {
ElectronApiSWIPCHandlerImpl::MakeIPCEvent(
v8::Isolate* isolate,
api::Session* session,
bool internal,
electron::mojom::ElectronApiIPC::InvokeCallback callback) {
if (!session) {
if (callback) {
// We must always invoke the callback if present.
gin_helper::internal::ReplyChannel::Create(isolate, std::move(callback))
->SendError("Session does not exist");
}
return {};
}
gin::Handle<gin_helper::internal::Event> event =
gin_helper::internal::Event::New(isolate);
v8::Local<v8::Object> event_object = event.ToV8().As<v8::Object>();
@ -150,7 +158,11 @@ ElectronApiSWIPCHandlerImpl::MakeIPCEvent(v8::Isolate* isolate, bool internal) {
dict.Set("processId", render_process_host_->GetID().GetUnsafeValue());
// Set session to provide context for getting preloads
dict.Set("session", GetSession());
dict.Set("session", session);
if (callback)
dict.Set("_replyChannel", gin_helper::internal::ReplyChannel::Create(
isolate, std::move(callback)));
if (internal)
dict.SetHidden("internal", internal);

8
shell/browser/electron_api_sw_ipc_handler_impl.h
View file

@ -70,8 +70,12 @@ class ElectronApiSWIPCHandlerImpl : public mojom::ElectronApiIPC,
ElectronBrowserContext* GetBrowserContext();
api::Session* GetSession();
gin::Handle<gin_helper::internal::Event> MakeIPCEvent(v8::Isolate* isolate,
bool internal);
gin::Handle<gin_helper::internal::Event> MakeIPCEvent(
v8::Isolate* isolate,
api::Session* session,
bool internal,
electron::mojom::ElectronApiIPC::InvokeCallback callback =
electron::mojom::ElectronApiIPC::InvokeCallback());
// content::RenderProcessHostObserver
void RenderProcessExited(