wip

filenames.auto.gni

@@ -160,7 +160,6 @@ auto_filenames = {
     "lib/renderer/api/web-utils.ts",
     "lib/renderer/common-init.ts",
     "lib/renderer/inspector.ts",
-    "lib/renderer/ipc-renderer-internal-utils.ts",
     "lib/renderer/ipc-renderer-internal.ts",
     "lib/renderer/security-warnings.ts",
     "lib/renderer/web-frame-init.ts",
@@ -247,7 +246,6 @@ auto_filenames = {
     "lib/browser/guest-window-manager.ts",
     "lib/browser/init.ts",
     "lib/browser/ipc-main-impl.ts",
-    "lib/browser/ipc-main-internal-utils.ts",
     "lib/browser/ipc-main-internal.ts",
     "lib/browser/message-port-main.ts",
     "lib/browser/parse-features-string.ts",
@@ -290,7 +288,6 @@ auto_filenames = {
     "lib/renderer/common-init.ts",
     "lib/renderer/init.ts",
     "lib/renderer/inspector.ts",
-    "lib/renderer/ipc-renderer-internal-utils.ts",
     "lib/renderer/ipc-renderer-internal.ts",
     "lib/renderer/security-warnings.ts",
     "lib/renderer/web-frame-init.ts",
@@ -324,7 +321,6 @@ auto_filenames = {
     "lib/renderer/api/module-list.ts",
     "lib/renderer/api/web-frame.ts",
     "lib/renderer/api/web-utils.ts",
-    "lib/renderer/ipc-renderer-internal-utils.ts",
     "lib/renderer/ipc-renderer-internal.ts",
     "lib/worker/init.ts",
     "package.json",

lib/browser/api/web-contents.ts

@@ -5,8 +5,7 @@ import * as url from 'url';
 import * as path from 'path';
 import { openGuestWindow, makeWebPreferences, parseContentTypeFormat } from '@electron/internal/browser/guest-window-manager';
 import { parseFeatures } from '@electron/internal/browser/parse-features-string';
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
-import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
+import { ipcMainInternal, invokeInWebContents } from '@electron/internal/browser/ipc-main-internal';
 import { MessagePortMain } from '@electron/internal/browser/message-port-main';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl';
@@ -162,7 +161,7 @@ const webFrameMethods = [
 
 for (const method of webFrameMethods) {
   WebContents.prototype[method] = function (...args: any[]): Promise<any> {
-    return ipcMainUtils.invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, method, ...args);
+    return invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, method, ...args);
   };
 }
 
@@ -180,11 +179,11 @@ const waitTillCanExecuteJavaScript = async (webContents: Electron.WebContents) =
 // WebContents has been loaded.
 WebContents.prototype.executeJavaScript = async function (code, hasUserGesture) {
   await waitTillCanExecuteJavaScript(this);
-  return ipcMainUtils.invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, 'executeJavaScript', String(code), !!hasUserGesture);
+  return invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, 'executeJavaScript', String(code), !!hasUserGesture);
 };
 WebContents.prototype.executeJavaScriptInIsolatedWorld = async function (worldId, code, hasUserGesture) {
   await waitTillCanExecuteJavaScript(this);
-  return ipcMainUtils.invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, 'executeJavaScriptInIsolatedWorld', worldId, code, !!hasUserGesture);
+  return invokeInWebContents(this, IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, 'executeJavaScriptInIsolatedWorld', worldId, code, !!hasUserGesture);
 };
 
 function checkType<T> (value: T, type: 'number' | 'boolean' | 'string' | 'object', name: string): T {

lib/browser/devtools.ts

@@ -1,8 +1,7 @@
 import { dialog, Menu } from 'electron/main';
 import * as fs from 'fs';
 
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
-import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
+import { ipcMainInternal, handleSync } from '@electron/internal/browser/ipc-main-internal';
 import { IPC_MESSAGES } from '@electron/internal//common/ipc-messages';
 
 const convertToMenuTemplate = function (items: ContextMenuItem[], handler: (id: number) => void) {
@@ -84,7 +83,7 @@ ipcMainInternal.handle(IPC_MESSAGES.INSPECTOR_SELECT_FILE, async function (event
   return [path, data];
 });
 
-ipcMainUtils.handleSync(IPC_MESSAGES.INSPECTOR_CONFIRM, async function (event, message: string = '', title: string = '') {
+handleSync(IPC_MESSAGES.INSPECTOR_CONFIRM, async function (event, message: string = '', title: string = '') {
   assertChromeDevTools(event.sender, 'window.confirm()');
 
   const options = {

lib/browser/guest-view-manager.ts

@@ -1,6 +1,5 @@
 import { webContents } from 'electron/main';
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
-import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
+import { ipcMainInternal, handleSync } from '@electron/internal/browser/ipc-main-internal';
 import { parseWebViewWebPreferences } from '@electron/internal/browser/parse-features-string';
 import { syncMethods, asyncMethods, properties } from '@electron/internal/common/web-view-methods';
 import { webViewEvents } from '@electron/internal/browser/web-view-events';
@@ -281,7 +280,7 @@ const handleMessage = function (channel: string, handler: (event: Electron.IpcMa
 };
 
 const handleMessageSync = function (channel: string, handler: (event: ElectronInternal.IpcMainInternalEvent, ...args: any[]) => any) {
-  ipcMainUtils.handleSync(channel, makeSafeHandler(channel, handler));
+  handleSync(channel, makeSafeHandler(channel, handler));
 };
 
 handleMessage(IPC_MESSAGES.GUEST_VIEW_MANAGER_CREATE_AND_ATTACH_GUEST, function (event, embedderFrameId: number, elementInstanceId: number, params) {

lib/browser/ipc-main-internal-utils.ts

@@ -1,38 +0,0 @@
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
-
-type IPCHandler = (event: ElectronInternal.IpcMainInternalEvent, ...args: any[]) => any
-
-export const handleSync = function <T extends IPCHandler> (channel: string, handler: T) {
-  ipcMainInternal.on(channel, async (event, ...args) => {
-    try {
-      event.returnValue = [null, await handler(event, ...args)];
-    } catch (error) {
-      event.returnValue = [error];
-    }
-  });
-};
-
-let nextId = 0;
-
-export function invokeInWebContents<T> (sender: Electron.WebContents, command: string, ...args: any[]) {
-  return new Promise<T>((resolve, reject) => {
-    const requestId = ++nextId;
-    const channel = `${command}_RESPONSE_${requestId}`;
-    ipcMainInternal.on(channel, function handler (event, error: Error, result: any) {
-      if (event.sender !== sender) {
-        console.error(`Reply to ${command} sent by unexpected WebContents (${event.sender.id})`);
-        return;
-      }
-
-      ipcMainInternal.removeListener(channel, handler);
-
-      if (error) {
-        reject(error);
-      } else {
-        resolve(result);
-      }
-    });
-
-    sender._sendInternal(command, requestId, ...args);
-  });
-}

lib/browser/ipc-main-internal.ts

@@ -1,3 +1,40 @@
 import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl';
 
 export const ipcMainInternal = new IpcMainImpl() as ElectronInternal.IpcMainInternal;
+
+type IPCHandler = (event: ElectronInternal.IpcMainInternalEvent, ...args: any[]) => any
+
+export const handleSync = function <T extends IPCHandler> (channel: string, handler: T) {
+  ipcMainInternal.on(channel, async (event, ...args) => {
+    try {
+      event.returnValue = [null, await handler(event, ...args)];
+    } catch (error) {
+      event.returnValue = [error];
+    }
+  });
+};
+
+let nextId = 0;
+
+export function invokeInWebContents<T> (sender: Electron.WebContents, command: string, ...args: any[]) {
+  return new Promise<T>((resolve, reject) => {
+    const requestId = ++nextId;
+    const channel = `${command}_RESPONSE_${requestId}`;
+    ipcMainInternal.on(channel, function handler (event, error: Error, result: any) {
+      if (event.sender !== sender) {
+        console.error(`Reply to ${command} sent by unexpected WebContents (${event.sender.id})`);
+        return;
+      }
+
+      ipcMainInternal.removeListener(channel, handler);
+
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    });
+
+    sender._sendInternal(command, requestId, ...args);
+  });
+}

lib/browser/rpc-server.ts

@@ -1,7 +1,6 @@
 import { clipboard } from 'electron/common';
 import * as fs from 'fs';
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
-import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
+import { ipcMainInternal, handleSync } from '@electron/internal/browser/ipc-main-internal';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
 // Implements window.close()
@@ -33,7 +32,7 @@ const allowedClipboardMethods = (() => {
   }
 })();
 
-ipcMainUtils.handleSync(IPC_MESSAGES.BROWSER_CLIPBOARD_SYNC, function (event, method: string, ...args: any[]) {
+handleSync(IPC_MESSAGES.BROWSER_CLIPBOARD_SYNC, function (event, method: string, ...args: any[]) {
   if (!allowedClipboardMethods.has(method)) {
     throw new Error(`Invalid method: ${method}`);
   }
@@ -52,7 +51,7 @@ const getPreloadScript = async function (preloadPath: string) {
   return { preloadPath, preloadSrc, preloadError };
 };
 
-ipcMainUtils.handleSync(IPC_MESSAGES.BROWSER_SANDBOX_LOAD, async function (event) {
+handleSync(IPC_MESSAGES.BROWSER_SANDBOX_LOAD, async function (event) {
   const preloadPaths = event.sender._getPreloadPaths();
 
   return {
@@ -68,7 +67,7 @@ ipcMainUtils.handleSync(IPC_MESSAGES.BROWSER_SANDBOX_LOAD, async function (event
   };
 });
 
-ipcMainUtils.handleSync(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD, function (event) {
+handleSync(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD, function (event) {
   return { preloadPaths: event.sender._getPreloadPaths() };
 });
 

lib/renderer/api/clipboard.ts

@@ -1,10 +1,10 @@
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
-import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils';
+import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
 
 const clipboard = process._linkedBinding('electron_common_clipboard');
 
 const makeRemoteMethod = function (method: keyof Electron.Clipboard): any {
-  return (...args: any[]) => ipcRendererUtils.invokeSync(IPC_MESSAGES.BROWSER_CLIPBOARD_SYNC, method, ...args);
+  return (...args: any[]) => ipcRendererInternal.invokeSync(IPC_MESSAGES.BROWSER_CLIPBOARD_SYNC, method, ...args);
 };
 
 if (process.platform === 'linux') {

lib/renderer/init.ts

@@ -3,7 +3,6 @@ import { pathToFileURL } from 'url';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
 import type * as ipcRendererInternalModule from '@electron/internal/renderer/ipc-renderer-internal';
-import type * as ipcRendererUtilsModule from '@electron/internal/renderer/ipc-renderer-internal-utils';
 
 const Module = require('module') as NodeJS.ModuleInternal;
 
@@ -47,7 +46,6 @@ process.argv.splice(1, 1);
 require('@electron/internal/common/init');
 
 const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal') as typeof ipcRendererInternalModule;
-const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils') as typeof ipcRendererUtilsModule;
 
 process.getProcessMemoryInfo = () => {
   return ipcRendererInternal.invoke<Electron.ProcessMemoryInfo>(IPC_MESSAGES.BROWSER_GET_PROCESS_MEMORY_INFO);
@@ -133,7 +131,7 @@ if (nodeIntegration) {
 const { appCodeLoaded } = process;
 delete process.appCodeLoaded;
 
-const { preloadPaths } = ipcRendererUtils.invokeSync<{ preloadPaths: string[] }>(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD);
+const { preloadPaths } = ipcRendererInternal.invokeSync<{ preloadPaths: string[] }>(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD);
 const cjsPreloads = preloadPaths.filter(p => path.extname(p) !== '.mjs');
 const esmPreloads = preloadPaths.filter(p => path.extname(p) === '.mjs');
 if (cjsPreloads.length) {

lib/renderer/inspector.ts

@@ -1,6 +1,5 @@
 import { internalContextBridge } from '@electron/internal/renderer/api/context-bridge';
 import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
-import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils';
 import { webFrame } from 'electron/renderer';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
@@ -21,7 +20,7 @@ window.onload = function () {
 
 // The DOM implementation expects (message?: string) => boolean
 window.confirm = function (message?: string, title?: string) {
-  return ipcRendererUtils.invokeSync(IPC_MESSAGES.INSPECTOR_CONFIRM, message, title) as boolean;
+  return ipcRendererInternal.invokeSync(IPC_MESSAGES.INSPECTOR_CONFIRM, message, title) as boolean;
 };
 
 const useEditMenuItems = function (x: number, y: number, items: ContextMenuItem[]) {

lib/renderer/ipc-renderer-internal-utils.ts

@@ -1,24 +0,0 @@
-import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
-
-type IPCHandler = (event: Electron.IpcRendererEvent, ...args: any[]) => any
-
-export const handle = function <T extends IPCHandler> (channel: string, handler: T) {
-  ipcRendererInternal.on(channel, async (event, requestId, ...args) => {
-    const replyChannel = `${channel}_RESPONSE_${requestId}`;
-    try {
-      event.sender.send(replyChannel, null, await handler(event, ...args));
-    } catch (error) {
-      event.sender.send(replyChannel, error);
-    }
-  });
-};
-
-export function invokeSync<T> (command: string, ...args: any[]): T {
-  const [error, result] = ipcRendererInternal.sendSync(command, ...args);
-
-  if (error) {
-    throw error;
-  } else {
-    return result;
-  }
-}

lib/renderer/ipc-renderer-internal.ts

@@ -4,7 +4,9 @@ const { ipc } = process._linkedBinding('electron_renderer_ipc');
 
 const internal = true;
 
-class IpcRendererInternal extends EventEmitter implements ElectronInternal.IpcRendererInternal {
+type IPCHandler = (event: Electron.IpcRendererEvent, ...args: any[]) => any
+
+class IpcRendererInternal extends EventEmitter {
   send (channel: string, ...args: any[]) {
     return ipc.send(internal, channel, args);
   }
@@ -20,6 +22,27 @@ class IpcRendererInternal extends EventEmitter implements ElectronInternal.IpcRe
     }
     return result;
   };
+
+  invokeSync<T> (command: string, ...args: any[]): T {
+    const [error, result] = this.sendSync(command, ...args);
+
+    if (error) {
+      throw error;
+    } else {
+      return result;
+    }
+  }
+
+  handle<T extends IPCHandler> (channel: string, handler: T) {
+    this.on(channel, async (event, requestId, ...args) => {
+      const replyChannel = `${channel}_RESPONSE_${requestId}`;
+      try {
+        event.sender.send(replyChannel, null, await handler(event, ...args));
+      } catch (error) {
+        event.sender.send(replyChannel, error);
+      }
+    });
+  };
 }
 
 export const ipcRendererInternal = new IpcRendererInternal();

lib/renderer/web-frame-init.ts

@@ -1,5 +1,5 @@
 import { webFrame, WebFrame } from 'electron/renderer';
-import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils';
+import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
 // All keys of WebFrame that extend Function
@@ -10,7 +10,7 @@ type WebFrameMethod = {
 
 export const webFrameInit = () => {
   // Call webFrame method
-  ipcRendererUtils.handle(IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, (
+  ipcRendererInternal.handle(IPC_MESSAGES.RENDERER_WEB_FRAME_METHOD, (
     event, method: keyof WebFrameMethod, ...args: any[]
   ) => {
     // The TypeScript compiler cannot handle the sheer number of

lib/renderer/web-view/guest-view-internal.ts

@@ -1,5 +1,4 @@
 import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
-import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
 const { mainFrame: webFrame } = process._linkedBinding('electron_renderer_web_frame');
@@ -32,7 +31,7 @@ export function createGuest (iframe: HTMLIFrameElement, elementInstanceId: numbe
 }
 
 export function detachGuest (guestInstanceId: number) {
-  return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_DETACH_GUEST, guestInstanceId);
+  return ipcRendererInternal.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_DETACH_GUEST, guestInstanceId);
 }
 
 export function invoke (guestInstanceId: number, method: string, args: any[]) {
@@ -40,13 +39,13 @@ export function invoke (guestInstanceId: number, method: string, args: any[]) {
 }
 
 export function invokeSync (guestInstanceId: number, method: string, args: any[]) {
-  return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_CALL, guestInstanceId, method, args);
+  return ipcRendererInternal.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_CALL, guestInstanceId, method, args);
 }
 
 export function propertyGet (guestInstanceId: number, name: string) {
-  return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_GET, guestInstanceId, name);
+  return ipcRendererInternal.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_GET, guestInstanceId, name);
 }
 
 export function propertySet (guestInstanceId: number, name: string, value: any) {
-  return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_SET, guestInstanceId, name, value);
+  return ipcRendererInternal.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_SET, guestInstanceId, name, value);
 }

lib/sandboxed_renderer/init.ts

@@ -2,7 +2,6 @@ import * as events from 'events';
 import { setImmediate, clearImmediate } from 'timers';
 import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
 
-import type * as ipcRendererUtilsModule from '@electron/internal/renderer/ipc-renderer-internal-utils';
 import type * as ipcRendererInternalModule from '@electron/internal/renderer/ipc-renderer-internal';
 
 declare const binding: {
@@ -29,12 +28,11 @@ for (const prop of Object.keys(EventEmitter.prototype) as (keyof typeof process)
 Object.setPrototypeOf(process, EventEmitter.prototype);
 
 const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal') as typeof ipcRendererInternalModule;
-const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils') as typeof ipcRendererUtilsModule;
 
 const {
   preloadScripts,
   process: processProps
-} = ipcRendererUtils.invokeSync<{
+} = ipcRendererInternal.invokeSync<{
   preloadScripts: {
     preloadPath: string;
     preloadSrc: string | null;

typings/internal-electron.d.ts

@@ -208,10 +208,6 @@ declare namespace ElectronInternal {
     appIcon: Electron.NativeImage | null;
   }
 
-  interface IpcRendererInternal extends NodeJS.EventEmitter, Pick<Electron.IpcRenderer, 'send' | 'sendSync' | 'invoke'> {
-    invoke<T>(channel: string, ...args: any[]): Promise<T>;
-  }
-
   interface IpcMainInternalEvent extends Omit<Electron.IpcMainEvent, 'reply'> {
   }