refactor: implement clipboard APIs without the remote module (#17200)

lib/browser/rpc-server.js

@@ -4,8 +4,10 @@ const electron = require('electron')
 const { EventEmitter } = require('events')
 const fs = require('fs')
 const util = require('util')
+
 const v8Util = process.atomBinding('v8_util')
 const eventBinding = process.atomBinding('event')
+const clipboard = process.atomBinding('clipboard')
 
 const { isPromise } = electron
 
@@ -16,6 +18,7 @@ const objectsRegistry = require('@electron/internal/browser/objects-registry')
 const guestViewManager = require('@electron/internal/browser/guest-view-manager')
 const bufferUtils = require('@electron/internal/common/buffer-utils')
 const errorUtils = require('@electron/internal/common/error-utils')
+const clipboardUtils = require('@electron/internal/common/clipboard-utils')
 
 const hasProp = {}.hasOwnProperty
 
@@ -488,12 +491,24 @@ ipcMainUtils.handle('ELECTRON_BROWSER_GET_LAST_WEB_PREFERENCES', function (event
   return event.sender.getLastWebPreferences()
 })
 
-ipcMainUtils.handle('ELECTRON_BROWSER_CLIPBOARD_READ_FIND_TEXT', function (event) {
-  return electron.clipboard.readFindText()
-})
+// Methods not listed in this set are called directly in the renderer process.
+const allowedClipboardMethods = (() => {
+  switch (process.platform) {
+    case 'darwin':
+      return new Set(['readFindText', 'writeFindText'])
+    case 'linux':
+      return new Set(Object.keys(clipboard))
+    default:
+      return new Set()
+  }
+})()
 
-ipcMainUtils.handle('ELECTRON_BROWSER_CLIPBOARD_WRITE_FIND_TEXT', function (event, text) {
-  return electron.clipboard.writeFindText(text)
+ipcMainUtils.handle('ELECTRON_BROWSER_CLIPBOARD', function (event, method, ...args) {
+  if (!allowedClipboardMethods.has(method)) {
+    throw new Error(`Invalid method: ${method}`)
+  }
+
+  return clipboardUtils.serialize(electron.clipboard[method](...clipboardUtils.deserialize(args)))
 })
 
 const readFile = util.promisify(fs.readFile)

lib/common/api/clipboard.js

@@ -1,20 +1,29 @@
 'use strict'
 
-if (process.platform === 'linux' && process.type === 'renderer') {
-  // On Linux we could not access clipboard in renderer process.
-  const { getRemote } = require('@electron/internal/renderer/remote')
-  module.exports = getRemote('clipboard')
-} else {
-  const clipboard = process.atomBinding('clipboard')
+const clipboard = process.atomBinding('clipboard')
 
-  // Read/write to find pasteboard over IPC since only main process is notified
-  // of changes
-  if (process.platform === 'darwin' && process.type === 'renderer') {
-    const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
+if (process.type === 'renderer') {
+  const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
+  const clipboardUtils = require('@electron/internal/common/clipboard-utils')
 
-    clipboard.readFindText = (...args) => ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD_READ_FIND_TEXT', ...args)
-    clipboard.writeFindText = (...args) => ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD_WRITE_FIND_TEXT', ...args)
+  const makeRemoteMethod = function (method) {
+    return (...args) => {
+      args = clipboardUtils.serialize(args)
+      const result = ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD', method, ...args)
+      return clipboardUtils.deserialize(result)
+    }
   }
 
-  module.exports = clipboard
+  if (process.platform === 'linux') {
+    // On Linux we could not access clipboard in renderer process.
+    for (const method of Object.keys(clipboard)) {
+      clipboard[method] = makeRemoteMethod(method)
+    }
+  } else if (process.platform === 'darwin') {
+    // Read/write to find pasteboard over IPC since only main process is notified of changes
+    clipboard.readFindText = makeRemoteMethod('readFindText')
+    clipboard.writeFindText = makeRemoteMethod('writeFindText')
+  }
 }
+
+module.exports = clipboard

lib/common/api/native-image.js

@@ -1,3 +1,5 @@
 'use strict'
 
-module.exports = process.atomBinding('native_image')
+const { nativeImage } = process.atomBinding('native_image')
+
+module.exports = nativeImage

lib/common/clipboard-utils.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const { nativeImage, NativeImage } = process.atomBinding('native_image')
+
+const objectMap = function (source, mapper) {
+  const sourceEntries = Object.entries(source)
+  const targetEntries = sourceEntries.map(([key, val]) => [key, mapper(val)])
+  return Object.fromEntries(targetEntries)
+}
+
+const serialize = function (value) {
+  if (value instanceof NativeImage) {
+    return {
+      buffer: value.toBitmap(),
+      size: value.getSize(),
+      __ELECTRON_SERIALIZED_NativeImage__: true
+    }
+  } else if (Array.isArray(value)) {
+    return value.map(serialize)
+  } else if (value instanceof Buffer) {
+    return value
+  } else if (value instanceof Object) {
+    return objectMap(value, serialize)
+  } else {
+    return value
+  }
+}
+
+const deserialize = function (value) {
+  if (value && value.__ELECTRON_SERIALIZED_NativeImage__) {
+    return nativeImage.createFromBitmap(value.buffer, value.size)
+  } else if (Array.isArray(value)) {
+    return value.map(deserialize)
+  } else if (value instanceof Buffer) {
+    return value
+  } else if (value instanceof Object) {
+    return objectMap(value, deserialize)
+  } else {
+    return value
+  }
+}
+
+module.exports = {
+  serialize,
+  deserialize
+}

lib/renderer/remote.ts

@@ -1,8 +0,0 @@
-import { remote } from 'electron'
-
-export function getRemote (name: keyof Electron.Remote) {
-  if (!remote) {
-    throw new Error(`${name} requires remote, which is not enabled`)
-  }
-  return remote[name]
-}

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

@@ -1,4 +1,4 @@
-import { deprecate, webFrame } from 'electron'
+import { deprecate, remote, webFrame } from 'electron'
 
 import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils'
 import * as guestViewInternal from '@electron/internal/renderer/web-view/guest-view-internal'
@@ -221,15 +221,15 @@ export const setupAttributes = () => {
 export const setupMethods = (WebViewElement: typeof ElectronInternal.WebViewElement) => {
   // WebContents associated with this webview.
   WebViewElement.prototype.getWebContents = function () {
-    const { getRemote } = require('@electron/internal/renderer/remote')
-    const getGuestWebContents = getRemote('getGuestWebContents')
+    if (!remote) {
+      throw new Error('getGuestWebContents requires remote, which is not enabled')
+    }
     const internal = v8Util.getHiddenValue<WebViewImpl>(this, 'internal')
-
     if (!internal.guestInstanceId) {
       internal.createGuestSync()
     }
 
-    return getGuestWebContents(internal.guestInstanceId)
+    return (remote as Electron.RemoteInternal).getGuestWebContents(internal.guestInstanceId!)
   }
 
   // Focusing the webview should move page focus to the underlying iframe.