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

lib/browser/api/web-contents.js

@@ -228,17 +228,13 @@ WebContents.prototype.getZoomFactor = function (callback) {
 
 WebContents.prototype.takeHeapSnapshot = function (filePath) {
   return new Promise((resolve, reject) => {
-    const channel = `ELECTRON_TAKE_HEAP_SNAPSHOT_RESULT_${getNextId()}`
-    ipcMainInternal.once(channel, (event, success) => {
+    this._takeHeapSnapshot(filePath, (success) => {
       if (success) {
         resolve()
       } else {
         reject(new Error('takeHeapSnapshot failed'))
       }
     })
-    if (!this._takeHeapSnapshot(filePath, channel)) {
-      ipcMainInternal.emit(channel, false)
-    }
   })
 }
 

lib/renderer/api/ipc-renderer.js

@@ -8,11 +8,11 @@ const ipcRenderer = v8Util.getHiddenValue(global, 'ipc')
 const internal = false
 
 ipcRenderer.send = function (channel, ...args) {
-  return binding.send(internal, channel, args)
+  return binding.ipc.send(internal, channel, args)
 }
 
 ipcRenderer.sendSync = function (channel, ...args) {
-  return binding.sendSync(internal, channel, args)[0]
+  return binding.ipc.sendSync(internal, channel, args)[0]
 }
 
 ipcRenderer.sendToHost = function (channel, ...args) {

lib/renderer/init.ts

@@ -23,8 +23,17 @@ globalPaths.push(path.join(__dirname, 'api', 'exports'))
 // The global variable will be used by ipc for event dispatching
 const v8Util = process.electronBinding('v8_util')
 
-v8Util.setHiddenValue(global, 'ipc', new EventEmitter())
-v8Util.setHiddenValue(global, 'ipc-internal', new EventEmitter())
+const ipcEmitter = new EventEmitter()
+const ipcInternalEmitter = new EventEmitter()
+v8Util.setHiddenValue(global, 'ipc', ipcEmitter)
+v8Util.setHiddenValue(global, 'ipc-internal', ipcInternalEmitter)
+
+v8Util.setHiddenValue(global, 'ipcNative', {
+  onMessage (internal: boolean, channel: string, args: any[], senderId: number) {
+    const sender = internal ? ipcInternalEmitter : ipcEmitter
+    sender.emit(channel, { sender, senderId }, ...args)
+  }
+})
 
 // Use electron module after everything is ready.
 const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')

lib/renderer/ipc-renderer-internal.ts

@@ -6,11 +6,11 @@ export const ipcRendererInternal: Electron.IpcRendererInternal = v8Util.getHidde
 const internal = true
 
 ipcRendererInternal.send = function (channel, ...args) {
-  return binding.send(internal, channel, args)
+  return binding.ipc.send(internal, channel, args)
 }
 
 ipcRendererInternal.sendSync = function (channel, ...args) {
-  return binding.sendSync(internal, channel, args)[0]
+  return binding.ipc.sendSync(internal, channel, args)[0]
 }
 
 ipcRendererInternal.sendTo = function (webContentsId, channel, ...args) {

lib/sandboxed_renderer/init.js

@@ -45,30 +45,27 @@ const loadedModules = new Map([
   ['url', require('url')]
 ])
 
-// AtomSandboxedRendererClient will look for the "ipcNative" hidden object when
-// invoking the `onMessage`/`onExit` callbacks.
-const ipcNative = process.electronBinding('ipc')
-v8Util.setHiddenValue(global, 'ipcNative', ipcNative)
-
-ipcNative.onMessage = function (internal, channel, args, senderId) {
-  if (internal) {
-    ipcRendererInternal.emit(channel, { sender: ipcRendererInternal, senderId }, ...args)
-  } else {
-    electron.ipcRenderer.emit(channel, { sender: electron.ipcRenderer, senderId }, ...args)
+// ElectronApiServiceImpl will look for the "ipcNative" hidden object when
+// invoking the 'onMessage' callback.
+v8Util.setHiddenValue(global, 'ipcNative', {
+  onMessage (internal, channel, args, senderId) {
+    const sender = internal ? ipcRendererInternal : electron.ipcRenderer
+    sender.emit(channel, { sender, senderId }, ...args)
   }
-}
+})
 
-ipcNative.onExit = function () {
-  process.emit('exit')
-}
-
-ipcNative.onDocumentStart = function () {
-  process.emit('document-start')
-}
-
-ipcNative.onDocumentEnd = function () {
-  process.emit('document-end')
-}
+// AtomSandboxedRendererClient will look for the "lifecycle" hidden object when
+v8Util.setHiddenValue(global, 'lifecycle', {
+  onExit () {
+    process.emit('exit')
+  },
+  onDocumentStart () {
+    process.emit('document-start')
+  },
+  onDocumentEnd () {
+    process.emit('document-end')
+  }
+})
 
 const { webFrameInit } = require('@electron/internal/renderer/web-frame-init')
 webFrameInit()