build: add enable_remote_module build flag (#19821)

lib/browser/remote/objects-registry.js

@@ -0,0 +1,134 @@
+'use strict'
+
+const v8Util = process.electronBinding('v8_util')
+
+const getOwnerKey = (webContents, contextId) => {
+  return `${webContents.id}-${contextId}`
+}
+
+class ObjectsRegistry {
+  constructor () {
+    this.nextId = 0
+
+    // Stores all objects by ref-counting.
+    // (id) => {object, count}
+    this.storage = {}
+
+    // Stores the IDs + refCounts of objects referenced by WebContents.
+    // (ownerKey) => { id: refCount }
+    this.owners = {}
+  }
+
+  // Register a new object and return its assigned ID. If the object is already
+  // registered then the already assigned ID would be returned.
+  add (webContents, contextId, obj) {
+    // Get or assign an ID to the object.
+    const id = this.saveToStorage(obj)
+
+    // Add object to the set of referenced objects.
+    const ownerKey = getOwnerKey(webContents, contextId)
+    let owner = this.owners[ownerKey]
+    if (!owner) {
+      owner = this.owners[ownerKey] = new Map()
+      this.registerDeleteListener(webContents, contextId)
+    }
+    if (!owner.has(id)) {
+      owner.set(id, 0)
+      // Increase reference count if not referenced before.
+      this.storage[id].count++
+    }
+
+    owner.set(id, owner.get(id) + 1)
+    return id
+  }
+
+  // Get an object according to its ID.
+  get (id) {
+    const pointer = this.storage[id]
+    if (pointer != null) return pointer.object
+  }
+
+  // Dereference an object according to its ID.
+  // Note that an object may be double-freed (cleared when page is reloaded, and
+  // then garbage collected in old page).
+  // rendererSideRefCount is the ref count that the renderer process reported
+  // at time of GC if this is different to the number of references we sent to
+  // the given owner then a GC occurred between a ref being sent and the value
+  // being pulled out of the weak map.
+  // In this case we decrement out ref count and do not delete the stored
+  // object
+  // For more details on why we do renderer side ref counting see
+  // https://github.com/electron/electron/pull/17464
+  remove (webContents, contextId, id, rendererSideRefCount) {
+    const ownerKey = getOwnerKey(webContents, contextId)
+    const owner = this.owners[ownerKey]
+    if (owner && owner.has(id)) {
+      const newRefCount = owner.get(id) - rendererSideRefCount
+
+      // Only completely remove if the number of references GCed in the
+      // renderer is the same as the number of references we sent them
+      if (newRefCount <= 0) {
+        // Remove the reference in owner.
+        owner.delete(id)
+        // Dereference from the storage.
+        this.dereference(id)
+      } else {
+        owner.set(id, newRefCount)
+      }
+    }
+  }
+
+  // Clear all references to objects refrenced by the WebContents.
+  clear (webContents, contextId) {
+    const ownerKey = getOwnerKey(webContents, contextId)
+    const owner = this.owners[ownerKey]
+    if (!owner) return
+
+    for (const id of owner.keys()) this.dereference(id)
+
+    delete this.owners[ownerKey]
+  }
+
+  // Private: Saves the object into storage and assigns an ID for it.
+  saveToStorage (object) {
+    let id = v8Util.getHiddenValue(object, 'atomId')
+    if (!id) {
+      id = ++this.nextId
+      this.storage[id] = {
+        count: 0,
+        object: object
+      }
+      v8Util.setHiddenValue(object, 'atomId', id)
+    }
+    return id
+  }
+
+  // Private: Dereference the object from store.
+  dereference (id) {
+    const pointer = this.storage[id]
+    if (pointer == null) {
+      return
+    }
+    pointer.count -= 1
+    if (pointer.count === 0) {
+      v8Util.deleteHiddenValue(pointer.object, 'atomId')
+      delete this.storage[id]
+    }
+  }
+
+  // Private: Clear the storage when renderer process is destroyed.
+  registerDeleteListener (webContents, contextId) {
+    // contextId => ${processHostId}-${contextCount}
+    const processHostId = contextId.split('-')[0]
+    const listener = (event, deletedProcessHostId) => {
+      if (deletedProcessHostId &&
+          deletedProcessHostId.toString() === processHostId) {
+        webContents.removeListener('render-view-deleted', listener)
+        this.clear(webContents, contextId)
+      }
+    }
+    webContents.on('render-view-deleted', listener)
+  }
+}
+
+module.exports = new ObjectsRegistry()

lib/browser/remote/server.js

@@ -0,0 +1,471 @@
+'use strict'
+
+const electron = require('electron')
+const { EventEmitter } = require('events')
+
+const v8Util = process.electronBinding('v8_util')
+const eventBinding = process.electronBinding('event')
+const features = process.electronBinding('features')
+
+if (!features.isRemoteModuleEnabled()) {
+  throw new Error('remote module is disabled')
+}
+
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
+const objectsRegistry = require('@electron/internal/browser/remote/objects-registry')
+const guestViewManager = require('@electron/internal/browser/guest-view-manager')
+const bufferUtils = require('@electron/internal/common/remote/buffer-utils')
+const errorUtils = require('@electron/internal/common/error-utils')
+const { isPromise } = require('@electron/internal/common/remote/is-promise')
+
+const hasProp = {}.hasOwnProperty
+
+// The internal properties of Function.
+const FUNCTION_PROPERTIES = [
+  'length', 'name', 'arguments', 'caller', 'prototype'
+]
+
+// The remote functions in renderer processes.
+// id => Function
+const rendererFunctions = v8Util.createDoubleIDWeakMap()
+
+// Return the description of object's members:
+const getObjectMembers = function (object) {
+  let names = Object.getOwnPropertyNames(object)
+  // For Function, we should not override following properties even though they
+  // are "own" properties.
+  if (typeof object === 'function') {
+    names = names.filter((name) => {
+      return !FUNCTION_PROPERTIES.includes(name)
+    })
+  }
+  // Map properties to descriptors.
+  return names.map((name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(object, name)
+    const member = { name, enumerable: descriptor.enumerable, writable: false }
+    if (descriptor.get === undefined && typeof object[name] === 'function') {
+      member.type = 'method'
+    } else {
+      if (descriptor.set || descriptor.writable) member.writable = true
+      member.type = 'get'
+    }
+    return member
+  })
+}
+
+// Return the description of object's prototype.
+const getObjectPrototype = function (object) {
+  const proto = Object.getPrototypeOf(object)
+  if (proto === null || proto === Object.prototype) return null
+  return {
+    members: getObjectMembers(proto),
+    proto: getObjectPrototype(proto)
+  }
+}
+
+// Convert a real value into meta data.
+const valueToMeta = function (sender, contextId, value, optimizeSimpleObject = false) {
+  // Determine the type of value.
+  const meta = { type: typeof value }
+  if (meta.type === 'object') {
+    // Recognize certain types of objects.
+    if (value === null) {
+      meta.type = 'value'
+    } else if (bufferUtils.isBuffer(value)) {
+      meta.type = 'buffer'
+    } else if (Array.isArray(value)) {
+      meta.type = 'array'
+    } else if (value instanceof Error) {
+      meta.type = 'error'
+    } else if (value instanceof Date) {
+      meta.type = 'date'
+    } else if (isPromise(value)) {
+      meta.type = 'promise'
+    } else if (hasProp.call(value, 'callee') && value.length != null) {
+      // Treat the arguments object as array.
+      meta.type = 'array'
+    } else if (optimizeSimpleObject && v8Util.getHiddenValue(value, 'simple')) {
+      // Treat simple objects as value.
+      meta.type = 'value'
+    }
+  }
+
+  // Fill the meta object according to value's type.
+  if (meta.type === 'array') {
+    meta.members = value.map((el) => valueToMeta(sender, contextId, el, optimizeSimpleObject))
+  } else if (meta.type === 'object' || meta.type === 'function') {
+    meta.name = value.constructor ? value.constructor.name : ''
+
+    // Reference the original value if it's an object, because when it's
+    // passed to renderer we would assume the renderer keeps a reference of
+    // it.
+    meta.id = objectsRegistry.add(sender, contextId, value)
+    meta.members = getObjectMembers(value)
+    meta.proto = getObjectPrototype(value)
+  } else if (meta.type === 'buffer') {
+    meta.value = bufferUtils.bufferToMeta(value)
+  } else if (meta.type === 'promise') {
+    // Add default handler to prevent unhandled rejections in main process
+    // Instead they should appear in the renderer process
+    value.then(function () {}, function () {})
+
+    meta.then = valueToMeta(sender, contextId, function (onFulfilled, onRejected) {
+      value.then(onFulfilled, onRejected)
+    })
+  } else if (meta.type === 'error') {
+    meta.members = plainObjectToMeta(value)
+
+    // Error.name is not part of own properties.
+    meta.members.push({
+      name: 'name',
+      value: value.name
+    })
+  } else if (meta.type === 'date') {
+    meta.value = value.getTime()
+  } else {
+    meta.type = 'value'
+    meta.value = value
+  }
+  return meta
+}
+
+// Convert object to meta by value.
+const plainObjectToMeta = function (obj) {
+  return Object.getOwnPropertyNames(obj).map(function (name) {
+    return {
+      name: name,
+      value: obj[name]
+    }
+  })
+}
+
+// Convert Error into meta data.
+const exceptionToMeta = function (error) {
+  return {
+    type: 'exception',
+    value: errorUtils.serialize(error)
+  }
+}
+
+const throwRPCError = function (message) {
+  const error = new Error(message)
+  error.code = 'EBADRPC'
+  error.errno = -72
+  throw error
+}
+
+const removeRemoteListenersAndLogWarning = (sender, callIntoRenderer) => {
+  const location = v8Util.getHiddenValue(callIntoRenderer, 'location')
+  let message = `Attempting to call a function in a renderer window that has been closed or released.` +
+    `\nFunction provided here: ${location}`
+
+  if (sender instanceof EventEmitter) {
+    const remoteEvents = sender.eventNames().filter((eventName) => {
+      return sender.listeners(eventName).includes(callIntoRenderer)
+    })
+
+    if (remoteEvents.length > 0) {
+      message += `\nRemote event names: ${remoteEvents.join(', ')}`
+      remoteEvents.forEach((eventName) => {
+        sender.removeListener(eventName, callIntoRenderer)
+      })
+    }
+  }
+
+  console.warn(message)
+}
+
+// Convert array of meta data from renderer into array of real values.
+const unwrapArgs = function (sender, frameId, contextId, args) {
+  const metaToValue = function (meta) {
+    switch (meta.type) {
+      case 'value':
+        return meta.value
+      case 'remote-object':
+        return objectsRegistry.get(meta.id)
+      case 'array':
+        return unwrapArgs(sender, frameId, contextId, meta.value)
+      case 'buffer':
+        return bufferUtils.metaToBuffer(meta.value)
+      case 'date':
+        return new Date(meta.value)
+      case 'promise':
+        return Promise.resolve({
+          then: metaToValue(meta.then)
+        })
+      case 'object': {
+        const ret = {}
+        Object.defineProperty(ret.constructor, 'name', { value: meta.name })
+
+        for (const { name, value } of meta.members) {
+          ret[name] = metaToValue(value)
+        }
+        return ret
+      }
+      case 'function-with-return-value':
+        const returnValue = metaToValue(meta.value)
+        return function () {
+          return returnValue
+        }
+      case 'function': {
+        // Merge contextId and meta.id, since meta.id can be the same in
+        // different webContents.
+        const objectId = [contextId, meta.id]
+
+        // Cache the callbacks in renderer.
+        if (rendererFunctions.has(objectId)) {
+          return rendererFunctions.get(objectId)
+        }
+
+        const callIntoRenderer = function (...args) {
+          let succeed = false
+          if (!sender.isDestroyed()) {
+            succeed = sender._sendToFrameInternal(frameId, 'ELECTRON_RENDERER_CALLBACK', contextId, meta.id, valueToMeta(sender, contextId, args))
+          }
+          if (!succeed) {
+            removeRemoteListenersAndLogWarning(this, callIntoRenderer)
+          }
+        }
+        v8Util.setHiddenValue(callIntoRenderer, 'location', meta.location)
+        Object.defineProperty(callIntoRenderer, 'length', { value: meta.length })
+
+        v8Util.setRemoteCallbackFreer(callIntoRenderer, contextId, meta.id, sender)
+        rendererFunctions.set(objectId, callIntoRenderer)
+        return callIntoRenderer
+      }
+      default:
+        throw new TypeError(`Unknown type: ${meta.type}`)
+    }
+  }
+  return args.map(metaToValue)
+}
+
+const isRemoteModuleEnabledImpl = function (contents) {
+  const webPreferences = contents.getLastWebPreferences() || {}
+  return !!webPreferences.enableRemoteModule
+}
+
+const isRemoteModuleEnabledCache = new WeakMap()
+
+const isRemoteModuleEnabled = function (contents) {
+  if (!isRemoteModuleEnabledCache.has(contents)) {
+    isRemoteModuleEnabledCache.set(contents, isRemoteModuleEnabledImpl(contents))
+  }
+
+  return isRemoteModuleEnabledCache.get(contents)
+}
+
+const handleRemoteCommand = function (channel, handler) {
+  ipcMainInternal.on(channel, (event, contextId, ...args) => {
+    let returnValue
+    if (!isRemoteModuleEnabled(event.sender)) {
+      event.returnValue = null
+      return
+    }
+
+    try {
+      returnValue = handler(event, contextId, ...args)
+    } catch (error) {
+      returnValue = exceptionToMeta(error)
+    }
+
+    if (returnValue !== undefined) {
+      event.returnValue = returnValue
+    }
+  })
+}
+
+const emitCustomEvent = function (contents, eventName, ...args) {
+  const event = eventBinding.createWithSender(contents)
+
+  electron.app.emit(eventName, event, contents, ...args)
+  contents.emit(eventName, event, ...args)
+
+  return event
+}
+
+handleRemoteCommand('ELECTRON_BROWSER_WRONG_CONTEXT_ERROR', function (event, contextId, passedContextId, id) {
+  const objectId = [passedContextId, id]
+  if (!rendererFunctions.has(objectId)) {
+    // Do nothing if the error has already been reported before.
+    return
+  }
+  removeRemoteListenersAndLogWarning(event.sender, rendererFunctions.get(objectId))
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_REQUIRE', function (event, contextId, moduleName) {
+  const customEvent = emitCustomEvent(event.sender, 'remote-require', moduleName)
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error(`Blocked remote.require('${moduleName}')`)
+    } else {
+      customEvent.returnValue = process.mainModule.require(moduleName)
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_GET_BUILTIN', function (event, contextId, moduleName) {
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-builtin', moduleName)
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error(`Blocked remote.getBuiltin('${moduleName}')`)
+    } else {
+      customEvent.returnValue = electron[moduleName]
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_GLOBAL', function (event, contextId, globalName) {
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-global', globalName)
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error(`Blocked remote.getGlobal('${globalName}')`)
+    } else {
+      customEvent.returnValue = global[globalName]
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_CURRENT_WINDOW', function (event, contextId) {
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-window')
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error('Blocked remote.getCurrentWindow()')
+    } else {
+      customEvent.returnValue = event.sender.getOwnerBrowserWindow()
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_CURRENT_WEB_CONTENTS', function (event, contextId) {
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-web-contents')
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error('Blocked remote.getCurrentWebContents()')
+    } else {
+      customEvent.returnValue = event.sender
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_CONSTRUCTOR', function (event, contextId, id, args) {
+  args = unwrapArgs(event.sender, event.frameId, contextId, args)
+  const constructor = objectsRegistry.get(id)
+
+  if (constructor == null) {
+    throwRPCError(`Cannot call constructor on missing remote object ${id}`)
+  }
+
+  return valueToMeta(event.sender, contextId, new constructor(...args))
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_FUNCTION_CALL', function (event, contextId, id, args) {
+  args = unwrapArgs(event.sender, event.frameId, contextId, args)
+  const func = objectsRegistry.get(id)
+
+  if (func == null) {
+    throwRPCError(`Cannot call function on missing remote object ${id}`)
+  }
+
+  try {
+    return valueToMeta(event.sender, contextId, func(...args), true)
+  } catch (error) {
+    const err = new Error(`Could not call remote function '${func.name || 'anonymous'}'. Check that the function signature is correct. Underlying error: ${error.message}\nUnderlying stack: ${error.stack}\n`)
+    err.cause = error
+    throw err
+  }
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_MEMBER_CONSTRUCTOR', function (event, contextId, id, method, args) {
+  args = unwrapArgs(event.sender, event.frameId, contextId, args)
+  const object = objectsRegistry.get(id)
+
+  if (object == null) {
+    throwRPCError(`Cannot call constructor '${method}' on missing remote object ${id}`)
+  }
+
+  return valueToMeta(event.sender, contextId, new object[method](...args))
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_MEMBER_CALL', function (event, contextId, id, method, args) {
+  args = unwrapArgs(event.sender, event.frameId, contextId, args)
+  const object = objectsRegistry.get(id)
+
+  if (object == null) {
+    throwRPCError(`Cannot call method '${method}' on missing remote object ${id}`)
+  }
+
+  try {
+    return valueToMeta(event.sender, contextId, object[method](...args), true)
+  } catch (error) {
+    const err = new Error(`Could not call remote method '${method}'. Check that the method signature is correct. Underlying error: ${error.message}\nUnderlying stack: ${error.stack}\n`)
+    err.cause = error
+    throw err
+  }
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_MEMBER_SET', function (event, contextId, id, name, args) {
+  args = unwrapArgs(event.sender, event.frameId, contextId, args)
+  const obj = objectsRegistry.get(id)
+
+  if (obj == null) {
+    throwRPCError(`Cannot set property '${name}' on missing remote object ${id}`)
+  }
+
+  obj[name] = args[0]
+  return null
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_MEMBER_GET', function (event, contextId, id, name) {
+  const obj = objectsRegistry.get(id)
+
+  if (obj == null) {
+    throwRPCError(`Cannot get property '${name}' on missing remote object ${id}`)
+  }
+
+  return valueToMeta(event.sender, contextId, obj[name])
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_DEREFERENCE', function (event, contextId, id, rendererSideRefCount) {
+  objectsRegistry.remove(event.sender, contextId, id, rendererSideRefCount)
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_CONTEXT_RELEASE', (event, contextId) => {
+  objectsRegistry.clear(event.sender, contextId)
+  return null
+})
+
+handleRemoteCommand('ELECTRON_BROWSER_GUEST_WEB_CONTENTS', function (event, contextId, guestInstanceId) {
+  const guest = guestViewManager.getGuestForWebContents(guestInstanceId, event.sender)
+
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-guest-web-contents', guest)
+
+  if (customEvent.returnValue === undefined) {
+    if (customEvent.defaultPrevented) {
+      throw new Error(`Blocked remote.getGuestForWebContents()`)
+    } else {
+      customEvent.returnValue = guest
+    }
+  }
+
+  return valueToMeta(event.sender, contextId, customEvent.returnValue)
+})
+
+module.exports = {
+  isRemoteModuleEnabled
+}