refactor: Port renderer-internal to TypeScript (#16939)

* chore: make aliasify work on .ts files as well

* refactor: Port ipc-renderer-internal to TypeScript

* refactor: Correctly import internal ipcRenderer

* refactor: One more rename

* refactor: Fix one more lint issue

* refactor: Correctly reference ipcRendererInternal

filenames.gni

@@ -68,7 +68,7 @@ filenames = {
     "lib/renderer/init.js",
     "lib/renderer/inspector.js",
     "lib/renderer/ipc-renderer-internal-utils.ts",
-    "lib/renderer/ipc-renderer-internal.js",
+    "lib/renderer/ipc-renderer-internal.ts",
     "lib/renderer/remote.ts",
     "lib/renderer/security-warnings.js",
     "lib/renderer/web-frame-init.js",

lib/isolated_renderer/init.js

@@ -17,7 +17,7 @@ if (webViewImpl) {
 const isolatedWorldArgs = v8Util.getHiddenValue(isolatedWorld, 'isolated-world-args')
 
 if (isolatedWorldArgs) {
-  const { ipcRenderer, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen } = isolatedWorldArgs
+  const { ipcRendererInternal, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen } = isolatedWorldArgs
   const { windowSetup } = require('@electron/internal/renderer/window-setup')
-  windowSetup(ipcRenderer, guestInstanceId, openerId, isHiddenPage, usesNativeWindowOpen)
+  windowSetup(ipcRendererInternal, guestInstanceId, openerId, isHiddenPage, usesNativeWindowOpen)
 }

lib/renderer/api/desktop-capturer.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { nativeImage, deprecate } = require('electron')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 const includes = [].includes
 let currentId = 0
@@ -45,8 +45,8 @@ const getSources = (options) => {
     }
 
     const id = incrementId()
-    ipcRenderer.send('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', captureWindow, captureScreen, options.thumbnailSize, options.fetchWindowIcons, id)
+    ipcRendererInternal.send('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', captureWindow, captureScreen, options.thumbnailSize, options.fetchWindowIcons, id)
-    return ipcRenderer.once(`ELECTRON_RENDERER_DESKTOP_CAPTURER_RESULT_${id}`, (event, sources) => {
+    return ipcRendererInternal.once(`ELECTRON_RENDERER_DESKTOP_CAPTURER_RESULT_${id}`, (event, sources) => {
       try {
         resolve(mapSources(sources))
       } catch (error) {

lib/renderer/api/remote.js

@@ -7,7 +7,7 @@ const resolvePromise = Promise.resolve.bind(Promise)
 const CallbacksRegistry = require('@electron/internal/renderer/callbacks-registry')
 const bufferUtils = require('@electron/internal/common/buffer-utils')
 const errorUtils = require('@electron/internal/common/error-utils')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 const callbacksRegistry = new CallbacksRegistry()
 const remoteObjectCache = v8Util.createIDWeakMap()
@@ -21,7 +21,7 @@ const contextId = v8Util.getHiddenValue(global, 'contextId')
 // to guard that situation.
 process.on('exit', () => {
   const command = 'ELECTRON_BROWSER_CONTEXT_RELEASE'
-  ipcRenderer.sendSync(command, contextId)
+  ipcRendererInternal.sendSync(command, contextId)
 })
 
 // Convert the arguments object into an array of meta data.
@@ -122,7 +122,7 @@ function setObjectMembers (ref, object, metaId, members) {
         } else {
           command = 'ELECTRON_BROWSER_MEMBER_CALL'
         }
-        const ret = ipcRenderer.sendSync(command, contextId, metaId, member.name, wrapArgs(args))
+        const ret = ipcRendererInternal.sendSync(command, contextId, metaId, member.name, wrapArgs(args))
         return metaToValue(ret)
       }
 
@@ -141,7 +141,7 @@ function setObjectMembers (ref, object, metaId, members) {
     } else if (member.type === 'get') {
       descriptor.get = () => {
         const command = 'ELECTRON_BROWSER_MEMBER_GET'
-        const meta = ipcRenderer.sendSync(command, contextId, metaId, member.name)
+        const meta = ipcRendererInternal.sendSync(command, contextId, metaId, member.name)
         return metaToValue(meta)
       }
 
@@ -149,7 +149,7 @@ function setObjectMembers (ref, object, metaId, members) {
         descriptor.set = (value) => {
           const args = wrapArgs([value])
           const command = 'ELECTRON_BROWSER_MEMBER_SET'
-          const meta = ipcRenderer.sendSync(command, contextId, metaId, member.name, args)
+          const meta = ipcRendererInternal.sendSync(command, contextId, metaId, member.name, args)
           if (meta != null) metaToValue(meta)
           return value
         }
@@ -179,7 +179,7 @@ function proxyFunctionProperties (remoteMemberFunction, metaId, name) {
     if (loaded) return
     loaded = true
     const command = 'ELECTRON_BROWSER_MEMBER_GET'
-    const meta = ipcRenderer.sendSync(command, contextId, metaId, name)
+    const meta = ipcRendererInternal.sendSync(command, contextId, metaId, name)
     setObjectMembers(remoteMemberFunction, remoteMemberFunction, meta.id, meta.members)
   }
 
@@ -239,7 +239,7 @@ function metaToValue (meta) {
         } else {
           command = 'ELECTRON_BROWSER_FUNCTION_CALL'
         }
-        const obj = ipcRenderer.sendSync(command, contextId, meta.id, wrapArgs(args))
+        const obj = ipcRendererInternal.sendSync(command, contextId, meta.id, wrapArgs(args))
         return metaToValue(obj)
       }
       ret = remoteFunction
@@ -270,12 +270,12 @@ function metaToPlainObject (meta) {
 }
 
 function handleMessage (channel, handler) {
-  ipcRenderer.on(channel, (event, passedContextId, id, ...args) => {
+  ipcRendererInternal.on(channel, (event, passedContextId, id, ...args) => {
     if (passedContextId === contextId) {
       handler(id, ...args)
     } else {
       // Message sent to an un-exist context, notify the error to main process.
-      ipcRenderer.send('ELECTRON_BROWSER_WRONG_CONTEXT_ERROR', contextId, passedContextId, id)
+      ipcRendererInternal.send('ELECTRON_BROWSER_WRONG_CONTEXT_ERROR', contextId, passedContextId, id)
     }
   })
 }
@@ -292,34 +292,34 @@ handleMessage('ELECTRON_RENDERER_RELEASE_CALLBACK', (id) => {
 
 exports.require = (module) => {
   const command = 'ELECTRON_BROWSER_REQUIRE'
-  const meta = ipcRenderer.sendSync(command, contextId, module)
+  const meta = ipcRendererInternal.sendSync(command, contextId, module)
   return metaToValue(meta)
 }
 
 // Alias to remote.require('electron').xxx.
 exports.getBuiltin = (module) => {
   const command = 'ELECTRON_BROWSER_GET_BUILTIN'
-  const meta = ipcRenderer.sendSync(command, contextId, module)
+  const meta = ipcRendererInternal.sendSync(command, contextId, module)
   return metaToValue(meta)
 }
 
 exports.getCurrentWindow = () => {
   const command = 'ELECTRON_BROWSER_CURRENT_WINDOW'
-  const meta = ipcRenderer.sendSync(command, contextId)
+  const meta = ipcRendererInternal.sendSync(command, contextId)
   return metaToValue(meta)
 }
 
 // Get current WebContents object.
 exports.getCurrentWebContents = () => {
   const command = 'ELECTRON_BROWSER_CURRENT_WEB_CONTENTS'
-  const meta = ipcRenderer.sendSync(command, contextId)
+  const meta = ipcRendererInternal.sendSync(command, contextId)
   return metaToValue(meta)
 }
 
 // Get a global object in browser.
 exports.getGlobal = (name) => {
   const command = 'ELECTRON_BROWSER_GLOBAL'
-  const meta = ipcRenderer.sendSync(command, contextId, name)
+  const meta = ipcRendererInternal.sendSync(command, contextId, name)
   return metaToValue(meta)
 }
 
@@ -336,7 +336,7 @@ exports.createFunctionWithReturnValue = (returnValue) => {
 // Get the guest WebContents from guestInstanceId.
 exports.getGuestWebContents = (guestInstanceId) => {
   const command = 'ELECTRON_BROWSER_GUEST_WEB_CONTENTS'
-  const meta = ipcRenderer.sendSync(command, contextId, guestInstanceId)
+  const meta = ipcRendererInternal.sendSync(command, contextId, guestInstanceId)
   return metaToValue(meta)
 }
 

lib/renderer/chrome-api.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
 const Event = require('@electron/internal/renderer/extensions/event')
 const url = require('url')
@@ -30,10 +30,10 @@ class Port {
     this.onMessage = new Event()
     this.sender = new MessageSender(tabId, extensionId)
 
-    ipcRenderer.once(`CHROME_PORT_DISCONNECT_${portId}`, () => {
+    ipcRendererInternal.once(`CHROME_PORT_DISCONNECT_${portId}`, () => {
       this._onDisconnect()
     })
-    ipcRenderer.on(`CHROME_PORT_POSTMESSAGE_${portId}`, (event, message) => {
+    ipcRendererInternal.on(`CHROME_PORT_POSTMESSAGE_${portId}`, (event, message) => {
       const sendResponse = function () { console.error('sendResponse is not implemented') }
       this.onMessage.emit(message, this.sender, sendResponse)
     })
@@ -42,17 +42,17 @@ class Port {
   disconnect () {
     if (this.disconnected) return
 
-    ipcRenderer.sendToAll(this.tabId, `CHROME_PORT_DISCONNECT_${this.portId}`)
+    ipcRendererInternal.sendToAll(this.tabId, `CHROME_PORT_DISCONNECT_${this.portId}`)
     this._onDisconnect()
   }
 
   postMessage (message) {
-    ipcRenderer.sendToAll(this.tabId, `CHROME_PORT_POSTMESSAGE_${this.portId}`, message)
+    ipcRendererInternal.sendToAll(this.tabId, `CHROME_PORT_POSTMESSAGE_${this.portId}`, message)
   }
 
   _onDisconnect () {
     this.disconnected = true
-    ipcRenderer.removeAllListeners(`CHROME_PORT_POSTMESSAGE_${this.portId}`)
+    ipcRendererInternal.removeAllListeners(`CHROME_PORT_POSTMESSAGE_${this.portId}`)
     this.onDisconnect.emit()
   }
 }
@@ -62,21 +62,21 @@ exports.injectTo = function (extensionId, isBackgroundPage, context) {
   const chrome = context.chrome = context.chrome || {}
   let originResultID = 1
 
-  ipcRenderer.on(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, (event, tabId, portId, connectInfo) => {
+  ipcRendererInternal.on(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, (event, tabId, portId, connectInfo) => {
     chrome.runtime.onConnect.emit(new Port(tabId, portId, extensionId, connectInfo.name))
   })
 
-  ipcRenderer.on(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, (event, tabId, message, resultID) => {
+  ipcRendererInternal.on(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, (event, tabId, message, resultID) => {
     chrome.runtime.onMessage.emit(message, new MessageSender(tabId, extensionId), (messageResult) => {
-      ipcRenderer.send(`CHROME_RUNTIME_ONMESSAGE_RESULT_${resultID}`, messageResult)
+      ipcRendererInternal.send(`CHROME_RUNTIME_ONMESSAGE_RESULT_${resultID}`, messageResult)
     })
   })
 
-  ipcRenderer.on('CHROME_TABS_ONCREATED', (event, tabId) => {
+  ipcRendererInternal.on('CHROME_TABS_ONCREATED', (event, tabId) => {
     chrome.tabs.onCreated.emit(new Tab(tabId))
   })
 
-  ipcRenderer.on('CHROME_TABS_ONREMOVED', (event, tabId) => {
+  ipcRendererInternal.on('CHROME_TABS_ONREMOVED', (event, tabId) => {
     chrome.tabs.onRemoved.emit(tabId)
   })
 
@@ -112,7 +112,7 @@ exports.injectTo = function (extensionId, isBackgroundPage, context) {
         [targetExtensionId, connectInfo] = args
       }
 
-      const { tabId, portId } = ipcRenderer.sendSync('CHROME_RUNTIME_CONNECT', targetExtensionId, connectInfo)
+      const { tabId, portId } = ipcRendererInternal.sendSync('CHROME_RUNTIME_CONNECT', targetExtensionId, connectInfo)
       return new Port(tabId, portId, extensionId, connectInfo.name)
     },
 
@@ -130,17 +130,17 @@ exports.injectTo = function (extensionId, isBackgroundPage, context) {
       } else if (args.length === 2) {
         // A case of not provide extension-id: (message, responseCallback)
         if (typeof args[1] === 'function') {
-          ipcRenderer.once(`CHROME_RUNTIME_SENDMESSAGE_RESULT_${originResultID}`, (event, result) => args[1](result))
+          ipcRendererInternal.once(`CHROME_RUNTIME_SENDMESSAGE_RESULT_${originResultID}`, (event, result) => args[1](result))
           message = args[0]
         } else {
           [targetExtensionId, message] = args
         }
       } else {
         console.error('options is not supported')
-        ipcRenderer.once(`CHROME_RUNTIME_SENDMESSAGE_RESULT_${originResultID}`, (event, result) => args[2](result))
+        ipcRendererInternal.once(`CHROME_RUNTIME_SENDMESSAGE_RESULT_${originResultID}`, (event, result) => args[2](result))
       }
 
-      ipcRenderer.send('CHROME_RUNTIME_SENDMESSAGE', targetExtensionId, message, originResultID)
+      ipcRendererInternal.send('CHROME_RUNTIME_SENDMESSAGE', targetExtensionId, message, originResultID)
       originResultID++
     },
 
@@ -152,17 +152,17 @@ exports.injectTo = function (extensionId, isBackgroundPage, context) {
   chrome.tabs = {
     executeScript (tabId, details, resultCallback) {
       if (resultCallback) {
-        ipcRenderer.once(`CHROME_TABS_EXECUTESCRIPT_RESULT_${originResultID}`, (event, result) => resultCallback([result]))
+        ipcRendererInternal.once(`CHROME_TABS_EXECUTESCRIPT_RESULT_${originResultID}`, (event, result) => resultCallback([result]))
       }
-      ipcRenderer.send('CHROME_TABS_EXECUTESCRIPT', originResultID, tabId, extensionId, details)
+      ipcRendererInternal.send('CHROME_TABS_EXECUTESCRIPT', originResultID, tabId, extensionId, details)
       originResultID++
     },
 
     sendMessage (tabId, message, options, responseCallback) {
       if (responseCallback) {
-        ipcRenderer.once(`CHROME_TABS_SEND_MESSAGE_RESULT_${originResultID}`, (event, result) => responseCallback(result))
+        ipcRendererInternal.once(`CHROME_TABS_SEND_MESSAGE_RESULT_${originResultID}`, (event, result) => responseCallback(result))
       }
-      ipcRenderer.send('CHROME_TABS_SEND_MESSAGE', tabId, extensionId, isBackgroundPage, message, originResultID)
+      ipcRendererInternal.send('CHROME_TABS_SEND_MESSAGE', tabId, extensionId, isBackgroundPage, message, originResultID)
       originResultID++
     },
 

lib/renderer/content-scripts-injector.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const { runInThisContext } = require('vm')
 
 // Check whether pattern matches.
@@ -83,9 +83,9 @@ const injectContentScript = function (extensionId, script) {
 }
 
 // Handle the request of chrome.tabs.executeJavaScript.
-ipcRenderer.on('CHROME_TABS_EXECUTESCRIPT', function (event, senderWebContentsId, requestId, extensionId, url, code) {
+ipcRendererInternal.on('CHROME_TABS_EXECUTESCRIPT', function (event, senderWebContentsId, requestId, extensionId, url, code) {
   const result = runContentScript.call(window, extensionId, url, code)
-  ipcRenderer.sendToAll(senderWebContentsId, `CHROME_TABS_EXECUTESCRIPT_RESULT_${requestId}`, result)
+  ipcRendererInternal.sendToAll(senderWebContentsId, `CHROME_TABS_EXECUTESCRIPT_RESULT_${requestId}`, result)
 })
 
 // Read the renderer process preferences.

lib/renderer/extensions/web-navigation.js

@@ -1,18 +1,18 @@
 'use strict'
 
 const Event = require('@electron/internal/renderer/extensions/event')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 class WebNavigation {
   constructor () {
     this.onBeforeNavigate = new Event()
     this.onCompleted = new Event()
 
-    ipcRenderer.on('CHROME_WEBNAVIGATION_ONBEFORENAVIGATE', (event, details) => {
+    ipcRendererInternal.on('CHROME_WEBNAVIGATION_ONBEFORENAVIGATE', (event, details) => {
       this.onBeforeNavigate.emit(details)
     })
 
-    ipcRenderer.on('CHROME_WEBNAVIGATION_ONCOMPLETED', (event, details) => {
+    ipcRendererInternal.on('CHROME_WEBNAVIGATION_ONCOMPLETED', (event, details) => {
       this.onCompleted.emit(details)
     })
   }

lib/renderer/init.js

@@ -9,6 +9,7 @@ const Module = require('module')
 process.argv.splice(1, 1)
 
 // Clear search paths.
+
 require('../common/reset-search-paths')
 
 // Import common settings.
@@ -26,7 +27,7 @@ v8Util.setHiddenValue(global, 'ipc', new EventEmitter())
 v8Util.setHiddenValue(global, 'ipc-internal', new EventEmitter())
 
 // Use electron module after everything is ready.
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 require('@electron/internal/renderer/web-frame-init')()
 
@@ -51,7 +52,7 @@ const guestInstanceId = parseOption('guest-instance-id', null, value => parseInt
 const openerId = parseOption('opener-id', null, value => parseInt(value))
 
 // The arguments to be passed to isolated world.
-const isolatedWorldArgs = { ipcRenderer, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen }
+const isolatedWorldArgs = { ipcRendererInternal, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen }
 
 // The webContents preload script is loaded after the session preload scripts.
 if (preloadScript) {
@@ -74,7 +75,7 @@ switch (window.location.protocol) {
   default: {
     // Override default web functions.
     const { windowSetup } = require('@electron/internal/renderer/window-setup')
-    windowSetup(ipcRenderer, guestInstanceId, openerId, isHiddenPage, usesNativeWindowOpen)
+    windowSetup(ipcRendererInternal, guestInstanceId, openerId, isHiddenPage, usesNativeWindowOpen)
 
     // Inject content scripts.
     if (process.isMainFrame) {
@@ -160,7 +161,7 @@ for (const preloadScript of preloadScripts) {
     console.error(`Unable to load preload script: ${preloadScript}`)
     console.error(`${error}`)
 
-    ipcRenderer.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadScript, errorUtils.serialize(error))
+    ipcRendererInternal.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadScript, errorUtils.serialize(error))
   }
 }
 

lib/renderer/inspector.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
 
 window.onload = function () {
@@ -24,11 +24,11 @@ window.confirm = function (message, title) {
   return ipcRendererUtils.invokeSync('ELECTRON_INSPECTOR_CONFIRM', message, title)
 }
 
-ipcRenderer.on('ELECTRON_INSPECTOR_CONTEXT_MENU_CLICK', function (event, id) {
+ipcRendererInternal.on('ELECTRON_INSPECTOR_CONTEXT_MENU_CLICK', function (event, id) {
   window.DevToolsAPI.contextMenuItemSelected(id)
 })
 
-ipcRenderer.on('ELECTRON_INSPECTOR_CONTEXT_MENU_CLOSE', function () {
+ipcRendererInternal.on('ELECTRON_INSPECTOR_CONTEXT_MENU_CLOSE', function () {
   window.DevToolsAPI.contextMenuCleared()
 })
 

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

@@ -1,4 +1,4 @@
-import * as ipcRenderer from '@electron/internal/renderer/ipc-renderer-internal'
+import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal'
 import * as errorUtils from '@electron/internal/common/error-utils'
 
 let nextId = 0
@@ -6,7 +6,7 @@ let nextId = 0
 export function invoke<T> (command: string, ...args: any[]) {
   return new Promise<T>((resolve, reject) => {
     const requestId = ++nextId
-    ipcRenderer.once(`${command}_RESPONSE_${requestId}`, (
+    ipcRendererInternal.once(`${command}_RESPONSE_${requestId}`, (
       _event: Electron.Event, error: Electron.SerializedError, result: any
     ) => {
       if (error) {
@@ -15,12 +15,12 @@ export function invoke<T> (command: string, ...args: any[]) {
         resolve(result)
       }
     })
-    ipcRenderer.send(command, requestId, ...args)
+    ipcRendererInternal.send(command, requestId, ...args)
   })
 }
 
 export function invokeSync<T> (command: string, ...args: any[]): T {
-  const [ error, result ] = ipcRenderer.sendSync(command, ...args)
+  const [ error, result ] = ipcRendererInternal.sendSync(command, ...args)
 
   if (error) {
     throw errorUtils.deserialize(error)

lib/renderer/ipc-renderer-internal.ts

@@ -1,26 +1,22 @@
-'use strict'
-
 const binding = process.atomBinding('ipc')
 const v8Util = process.atomBinding('v8_util')
 
 // Created by init.js.
-const ipcRenderer = v8Util.getHiddenValue(global, 'ipc-internal')
+export const ipcRendererInternal: Electron.IpcRendererInternal = v8Util.getHiddenValue(global, 'ipc-internal')
 const internal = true
 
-ipcRenderer.send = function (channel, ...args) {
+ipcRendererInternal.send = function (channel, ...args) {
   return binding.send(internal, channel, args)
 }
 
-ipcRenderer.sendSync = function (channel, ...args) {
+ipcRendererInternal.sendSync = function (channel, ...args) {
   return binding.sendSync(internal, channel, args)[0]
 }
 
-ipcRenderer.sendTo = function (webContentsId, channel, ...args) {
+ipcRendererInternal.sendTo = function (webContentsId, channel, ...args) {
   return binding.sendTo(internal, false, webContentsId, channel, args)
 }
 
-ipcRenderer.sendToAll = function (webContentsId, channel, ...args) {
+ipcRendererInternal.sendToAll = function (webContentsId, channel, ...args) {
   return binding.sendTo(internal, true, webContentsId, channel, args)
 }
-
-module.exports = ipcRenderer

lib/renderer/web-frame-init.js

@@ -1,16 +1,16 @@
 'use strict'
 
 const { webFrame } = require('electron')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const errorUtils = require('@electron/internal/common/error-utils')
 
 module.exports = () => {
   // Call webFrame method
-  ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', (event, method, args) => {
+  ipcRendererInternal.on('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', (event, method, args) => {
     webFrame[method](...args)
   })
 
-  ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_ASYNC_WEB_FRAME_METHOD', (event, requestId, method, args) => {
+  ipcRendererInternal.on('ELECTRON_INTERNAL_RENDERER_ASYNC_WEB_FRAME_METHOD', (event, requestId, method, args) => {
     new Promise(resolve =>
       webFrame[method](...args, resolve)
     ).then(result => {

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { webFrame } = require('electron')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 let requestId = 0
 
@@ -64,18 +64,18 @@ const dispatchEvent = function (webView, eventName, eventKey, ...args) {
 
 module.exports = {
   registerEvents: function (webView, viewInstanceId) {
-    ipcRenderer.on(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`, function () {
+    ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`, function () {
       webView.guestInstanceId = undefined
       webView.reset()
       const domEvent = new Event('destroyed')
       webView.dispatchEvent(domEvent)
     })
 
-    ipcRenderer.on(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`, function (event, eventName, ...args) {
+    ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`, function (event, eventName, ...args) {
       dispatchEvent(webView, eventName, eventName, ...args)
     })
 
-    ipcRenderer.on(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`, function (event, channel, ...args) {
+    ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`, function (event, channel, ...args) {
       const domEvent = new Event('ipc-message')
       domEvent.channel = channel
       domEvent.args = args
@@ -83,26 +83,26 @@ module.exports = {
     })
   },
   deregisterEvents: function (viewInstanceId) {
-    ipcRenderer.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`)
+    ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`)
-    ipcRenderer.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`)
+    ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`)
-    ipcRenderer.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`)
+    ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`)
   },
   createGuest: function (params, callback) {
     requestId++
-    ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_CREATE_GUEST', params, requestId)
+    ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_CREATE_GUEST', params, requestId)
-    ipcRenderer.once(`ELECTRON_RESPONSE_${requestId}`, callback)
+    ipcRendererInternal.once(`ELECTRON_RESPONSE_${requestId}`, callback)
   },
   createGuestSync: function (params) {
-    return ipcRenderer.sendSync('ELECTRON_GUEST_VIEW_MANAGER_CREATE_GUEST_SYNC', params)
+    return ipcRendererInternal.sendSync('ELECTRON_GUEST_VIEW_MANAGER_CREATE_GUEST_SYNC', params)
   },
   destroyGuest: function (guestInstanceId) {
-    ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_DESTROY_GUEST', guestInstanceId)
+    ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_DESTROY_GUEST', guestInstanceId)
   },
   attachGuest: function (elementInstanceId, guestInstanceId, params, contentWindow) {
     const embedderFrameId = webFrame.getWebFrameId(contentWindow)
     if (embedderFrameId < 0) { // this error should not happen.
       throw new Error('Invalid embedder frame')
     }
-    ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_ATTACH_GUEST', embedderFrameId, elementInstanceId, guestInstanceId, params)
+    ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_ATTACH_GUEST', embedderFrameId, elementInstanceId, guestInstanceId, params)
   }
 }

lib/renderer/web-view/web-view-attributes.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const { WebViewImpl } = require('@electron/internal/renderer/web-view/web-view-impl')
 const webViewConstants = require('@electron/internal/renderer/web-view/web-view-constants')
 const errorUtils = require('@electron/internal/common/error-utils')
@@ -186,7 +186,7 @@ class SrcAttribute extends WebViewAttribute {
     const method = 'loadURL'
     const args = [this.getValue(), opts]
 
-    const [error] = ipcRenderer.sendSync('ELECTRON_GUEST_VIEW_MANAGER_SYNC_CALL', guestInstanceId, method, args)
+    const [error] = ipcRendererInternal.sendSync('ELECTRON_GUEST_VIEW_MANAGER_SYNC_CALL', guestInstanceId, method, args)
     if (error) {
       throw errorUtils.deserialize(error)
     }

lib/renderer/web-view/web-view-impl.js

@@ -3,7 +3,7 @@
 const { webFrame, deprecate } = require('electron')
 
 const v8Util = process.atomBinding('v8_util')
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const guestViewInternal = require('@electron/internal/renderer/web-view/guest-view-internal')
 const webViewConstants = require('@electron/internal/renderer/web-view/web-view-constants')
 const errorUtils = require('@electron/internal/common/error-utils')
@@ -232,7 +232,7 @@ const setupMethods = (WebViewElement) => {
   // Forward proto.foo* method calls to WebViewImpl.foo*.
   const createBlockHandler = function (method) {
     return function (...args) {
-      const [error, result] = ipcRenderer.sendSync('ELECTRON_GUEST_VIEW_MANAGER_SYNC_CALL', getGuestInstanceId(this), method, args)
+      const [error, result] = ipcRendererInternal.sendSync('ELECTRON_GUEST_VIEW_MANAGER_SYNC_CALL', getGuestInstanceId(this), method, args)
       if (error) {
         throw errorUtils.deserialize(error)
       } else {
@@ -248,14 +248,14 @@ const setupMethods = (WebViewElement) => {
     return function (...args) {
       const callback = (typeof args[args.length - 1] === 'function') ? args.pop() : null
       const requestId = getNextId()
-      ipcRenderer.once(`ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL_RESPONSE_${requestId}`, function (event, error, result) {
+      ipcRendererInternal.once(`ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL_RESPONSE_${requestId}`, function (event, error, result) {
         if (error == null) {
           if (callback) callback(result)
         } else {
           throw errorUtils.deserialize(error)
         }
       })
-      ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL', requestId, getGuestInstanceId(this), method, args, callback != null)
+      ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL', requestId, getGuestInstanceId(this), method, args, callback != null)
     }
   }
 
@@ -269,7 +269,7 @@ const setupMethods = (WebViewElement) => {
         const callback = (typeof args[args.length - 1] === 'function') ? args.pop() : null
         const requestId = getNextId()
 
-        ipcRenderer.once(`ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL_RESPONSE_${requestId}`, function (event, error, result) {
+        ipcRendererInternal.once(`ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL_RESPONSE_${requestId}`, function (event, error, result) {
           if (error == null) {
             if (callback) {
               callback(result)
@@ -279,7 +279,7 @@ const setupMethods = (WebViewElement) => {
             reject(errorUtils.deserialize(error))
           }
         })
-        ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL', requestId, getGuestInstanceId(this), method, args, callback != null)
+        ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_ASYNC_CALL', requestId, getGuestInstanceId(this), method, args, callback != null)
       })
     }
   }

lib/renderer/web-view/web-view-init.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 const v8Util = process.atomBinding('v8_util')
 
 function handleFocusBlur (guestInstanceId) {
@@ -8,11 +8,11 @@ function handleFocusBlur (guestInstanceId) {
   // unfortunately do not work for webview.
 
   window.addEventListener('focus', () => {
-    ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', true, guestInstanceId)
+    ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', true, guestInstanceId)
   })
 
   window.addEventListener('blur', () => {
-    ipcRenderer.send('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', false, guestInstanceId)
+    ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', false, guestInstanceId)
   })
 }
 

lib/renderer/window-setup.ts

@@ -172,12 +172,12 @@ class BrowserWindowProxy {
 }
 
 export const windowSetup = (
-  ipcRenderer: Electron.IpcRenderer, guestInstanceId: number, openerId: number, isHiddenPage: boolean, usesNativeWindowOpen: boolean
+  ipcRendererInternal: Electron.IpcRendererInternal, guestInstanceId: number, openerId: number, isHiddenPage: boolean, usesNativeWindowOpen: boolean
 ) => {
   if (guestInstanceId == null) {
     // Override default window.close.
     window.close = function () {
-      ipcRenderer.sendSync('ELECTRON_BROWSER_WINDOW_CLOSE')
+      ipcRendererInternal.sendSync('ELECTRON_BROWSER_WINDOW_CLOSE')
     }
   }
 
@@ -187,16 +187,16 @@ export const windowSetup = (
       if (url != null && url !== '') {
         url = resolveURL(url)
       }
-      const guestId = ipcRenderer.sendSync('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_OPEN', url, toString(frameName), toString(features))
+      const guestId = ipcRendererInternal.sendSync('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_OPEN', url, toString(frameName), toString(features))
       if (guestId != null) {
-        return getOrCreateProxy(ipcRenderer, guestId)
+        return getOrCreateProxy(ipcRendererInternal, guestId)
       } else {
         return null
       }
     }
 
     if (openerId != null) {
-      window.opener = getOrCreateProxy(ipcRenderer, openerId)
+      window.opener = getOrCreateProxy(ipcRendererInternal, openerId)
     }
   }
 
@@ -205,7 +205,7 @@ export const windowSetup = (
     throw new Error('prompt() is and will not be supported.')
   }
 
-  ipcRenderer.on('ELECTRON_GUEST_WINDOW_POSTMESSAGE', function (
+  ipcRendererInternal.on('ELECTRON_GUEST_WINDOW_POSTMESSAGE', function (
     _event: Electron.Event, sourceId: number, message: any, sourceOrigin: string
   ) {
     // Manually dispatch event instead of using postMessage because we also need to
@@ -219,26 +219,26 @@ export const windowSetup = (
 
     event.data = message
     event.origin = sourceOrigin
-    event.source = getOrCreateProxy(ipcRenderer, sourceId)
+    event.source = getOrCreateProxy(ipcRendererInternal, sourceId)
 
     window.dispatchEvent(event as MessageEvent)
   })
 
   window.history.back = function () {
-    ipcRenderer.send('ELECTRON_NAVIGATION_CONTROLLER_GO_BACK')
+    ipcRendererInternal.send('ELECTRON_NAVIGATION_CONTROLLER_GO_BACK')
   }
 
   window.history.forward = function () {
-    ipcRenderer.send('ELECTRON_NAVIGATION_CONTROLLER_GO_FORWARD')
+    ipcRendererInternal.send('ELECTRON_NAVIGATION_CONTROLLER_GO_FORWARD')
   }
 
   window.history.go = function (offset: number) {
-    ipcRenderer.send('ELECTRON_NAVIGATION_CONTROLLER_GO_TO_OFFSET', +offset)
+    ipcRendererInternal.send('ELECTRON_NAVIGATION_CONTROLLER_GO_TO_OFFSET', +offset)
   }
 
   defineProperty(window.history, 'length', {
     get: function () {
-      return ipcRenderer.sendSync('ELECTRON_NAVIGATION_CONTROLLER_LENGTH')
+      return ipcRendererInternal.sendSync('ELECTRON_NAVIGATION_CONTROLLER_LENGTH')
     }
   })
 
@@ -253,7 +253,7 @@ export const windowSetup = (
     let cachedVisibilityState = isHiddenPage ? 'hidden' : 'visible'
 
     // Subscribe to visibilityState changes.
-    ipcRenderer.on('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', function (_event: Electron.Event, visibilityState: VisibilityState) {
+    ipcRendererInternal.on('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', function (_event: Electron.Event, visibilityState: VisibilityState) {
       if (cachedVisibilityState !== visibilityState) {
         cachedVisibilityState = visibilityState
         document.dispatchEvent(new Event('visibilitychange'))

lib/sandboxed_renderer/init.js

@@ -26,11 +26,11 @@ for (const prop of Object.keys(EventEmitter.prototype)) {
 }
 Object.setPrototypeOf(process, EventEmitter.prototype)
 
-const ipcRenderer = require('@electron/internal/renderer/ipc-renderer-internal')
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
 
 const {
   preloadScripts, isRemoteModuleEnabled, isWebViewTagEnabled, process: processProps
-} = ipcRenderer.sendSync('ELECTRON_BROWSER_SANDBOX_LOAD')
+} = ipcRendererInternal.sendSync('ELECTRON_BROWSER_SANDBOX_LOAD')
 
 process.isRemoteModuleEnabled = isRemoteModuleEnabled
 
@@ -51,7 +51,7 @@ v8Util.setHiddenValue(global, 'ipcNative', ipcNative)
 
 ipcNative.onMessage = function (internal, channel, args, senderId) {
   if (internal) {
-    ipcRenderer.emit(channel, { sender: ipcRenderer, senderId }, ...args)
+    ipcRendererInternal.emit(channel, { sender: ipcRendererInternal, senderId }, ...args)
   } else {
     electron.ipcRenderer.emit(channel, { sender: electron.ipcRenderer, senderId }, ...args)
   }
@@ -162,7 +162,7 @@ for (const { preloadPath, preloadSrc, preloadError } of preloadScripts) {
     console.error(`Unable to load preload script: ${preloadPath}`)
     console.error(`${error}`)
 
-    ipcRenderer.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadPath, errorUtils.serialize(error))
+    ipcRendererInternal.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadPath, errorUtils.serialize(error))
   }
 }
 

typings/internal-electron.d.ts

@@ -27,6 +27,10 @@ declare namespace Electron {
     __ELECTRON_SERIALIZED_ERROR__: true
   }
 
+  interface IpcRendererInternal extends Electron.IpcRenderer {
+    sendToAll(webContentsId: number, channel: string, ...args: any[]): void
+  }
+
   const deprecate: ElectronInternal.DeprecationUtil;
 }