2018-09-22 12:28:50 +00:00
|
|
|
'use strict'
|
|
|
|
|
2016-08-21 10:30:14 +00:00
|
|
|
/* eslint no-eval: "off" */
|
2018-08-10 22:19:49 +00:00
|
|
|
/* global binding, Buffer */
|
2016-08-21 10:30:14 +00:00
|
|
|
const events = require('events')
|
2018-09-30 21:24:00 +00:00
|
|
|
const { EventEmitter } = events
|
2016-08-21 10:30:14 +00:00
|
|
|
|
2019-04-29 14:57:32 +00:00
|
|
|
process.electronBinding = require('@electron/internal/common/electron-binding-setup').electronBindingSetup(binding.get, 'renderer')
|
2017-02-20 13:59:39 +00:00
|
|
|
|
2019-03-18 19:37:06 +00:00
|
|
|
const v8Util = process.electronBinding('v8_util')
|
2019-06-02 20:03:03 +00:00
|
|
|
// Expose Buffer shim as a hidden value. This is used by C++ code to
|
2017-03-16 16:20:09 +00:00
|
|
|
// deserialize Buffer instances sent from browser process.
|
|
|
|
v8Util.setHiddenValue(global, 'Buffer', Buffer)
|
2019-08-02 19:35:04 +00:00
|
|
|
// The `lib/renderer/api/ipc-renderer.ts` module looks for the ipc object in the
|
2017-02-27 17:14:36 +00:00
|
|
|
// "ipc" hidden value
|
2018-09-30 21:24:00 +00:00
|
|
|
v8Util.setHiddenValue(global, 'ipc', new EventEmitter())
|
2019-08-02 19:35:04 +00:00
|
|
|
// The `lib/renderer/ipc-renderer-internal.ts` module looks for the ipc object in the
|
2018-10-06 11:48:00 +00:00
|
|
|
// "ipc-internal" hidden value
|
|
|
|
v8Util.setHiddenValue(global, 'ipc-internal', new EventEmitter())
|
2019-06-02 20:03:03 +00:00
|
|
|
// The process object created by webpack is not an event emitter, fix it so
|
2017-02-27 17:14:36 +00:00
|
|
|
// the API is more compatible with non-sandboxed renderers.
|
2018-10-02 01:56:31 +00:00
|
|
|
for (const prop of Object.keys(EventEmitter.prototype)) {
|
2017-02-27 17:14:36 +00:00
|
|
|
if (process.hasOwnProperty(prop)) {
|
|
|
|
delete process[prop]
|
|
|
|
}
|
2016-08-21 10:30:14 +00:00
|
|
|
}
|
2018-09-30 21:24:00 +00:00
|
|
|
Object.setPrototypeOf(process, EventEmitter.prototype)
|
2016-08-21 10:30:14 +00:00
|
|
|
|
2019-02-15 01:24:25 +00:00
|
|
|
const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal')
|
2019-03-08 10:21:41 +00:00
|
|
|
const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
|
2018-12-05 18:07:56 +00:00
|
|
|
|
|
|
|
const {
|
2020-01-06 21:23:03 +00:00
|
|
|
contentScripts,
|
|
|
|
preloadScripts,
|
|
|
|
isRemoteModuleEnabled,
|
|
|
|
isWebViewTagEnabled,
|
|
|
|
guestInstanceId,
|
|
|
|
openerId,
|
|
|
|
process: processProps
|
2019-03-08 10:21:41 +00:00
|
|
|
} = ipcRendererUtils.invokeSync('ELECTRON_BROWSER_SANDBOX_LOAD')
|
2018-12-05 18:07:56 +00:00
|
|
|
|
|
|
|
process.isRemoteModuleEnabled = isRemoteModuleEnabled
|
|
|
|
|
2019-03-18 19:37:06 +00:00
|
|
|
// The electron module depends on process.electronBinding
|
2018-12-05 18:07:56 +00:00
|
|
|
const electron = require('electron')
|
|
|
|
|
2018-05-21 12:56:05 +00:00
|
|
|
const loadedModules = new Map([
|
2017-03-21 13:41:23 +00:00
|
|
|
['electron', electron],
|
2018-05-04 16:51:32 +00:00
|
|
|
['events', events],
|
2018-05-21 12:56:05 +00:00
|
|
|
['timers', require('timers')],
|
|
|
|
['url', require('url')]
|
2016-08-21 10:30:14 +00:00
|
|
|
])
|
|
|
|
|
2019-04-02 22:38:16 +00:00
|
|
|
// ElectronApiServiceImpl will look for the "ipcNative" hidden object when
|
|
|
|
// invoking the 'onMessage' callback.
|
|
|
|
v8Util.setHiddenValue(global, 'ipcNative', {
|
2020-03-12 01:07:54 +00:00
|
|
|
onMessage (internal, channel, ports, args, senderId) {
|
2019-04-02 22:38:16 +00:00
|
|
|
const sender = internal ? ipcRendererInternal : electron.ipcRenderer
|
2020-03-12 01:07:54 +00:00
|
|
|
sender.emit(channel, { sender, senderId, ports }, ...args)
|
2019-01-23 16:24:57 +00:00
|
|
|
}
|
2019-04-02 22:38:16 +00:00
|
|
|
})
|
2019-03-08 00:00:28 +00:00
|
|
|
|
2019-04-02 22:38:16 +00:00
|
|
|
// AtomSandboxedRendererClient will look for the "lifecycle" hidden object when
|
|
|
|
v8Util.setHiddenValue(global, 'lifecycle', {
|
2019-04-04 18:35:06 +00:00
|
|
|
onLoaded () {
|
|
|
|
process.emit('loaded')
|
|
|
|
},
|
2019-04-02 22:38:16 +00:00
|
|
|
onExit () {
|
|
|
|
process.emit('exit')
|
|
|
|
},
|
|
|
|
onDocumentStart () {
|
|
|
|
process.emit('document-start')
|
|
|
|
},
|
|
|
|
onDocumentEnd () {
|
|
|
|
process.emit('document-end')
|
|
|
|
}
|
|
|
|
})
|
2019-03-08 00:00:28 +00:00
|
|
|
|
2019-02-18 00:24:18 +00:00
|
|
|
const { webFrameInit } = require('@electron/internal/renderer/web-frame-init')
|
|
|
|
webFrameInit()
|
2018-04-12 01:57:40 +00:00
|
|
|
|
2017-02-27 17:14:36 +00:00
|
|
|
// Pass different process object to the preload script(which should not have
|
2019-03-18 19:37:06 +00:00
|
|
|
// access to things like `process.electronBinding`).
|
2018-09-30 21:24:00 +00:00
|
|
|
const preloadProcess = new EventEmitter()
|
2018-09-26 05:44:55 +00:00
|
|
|
|
2018-09-30 21:24:00 +00:00
|
|
|
Object.assign(preloadProcess, binding.process)
|
2018-08-21 18:05:45 +00:00
|
|
|
Object.assign(preloadProcess, processProps)
|
2018-09-30 21:24:00 +00:00
|
|
|
|
|
|
|
Object.assign(process, binding.process)
|
2018-08-21 18:05:45 +00:00
|
|
|
Object.assign(process, processProps)
|
2018-05-21 12:56:05 +00:00
|
|
|
|
2018-12-05 09:34:09 +00:00
|
|
|
Object.defineProperty(preloadProcess, 'noDeprecation', {
|
|
|
|
get () {
|
|
|
|
return process.noDeprecation
|
|
|
|
},
|
|
|
|
set (value) {
|
|
|
|
process.noDeprecation = value
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2019-04-04 18:35:06 +00:00
|
|
|
process.on('loaded', () => preloadProcess.emit('loaded'))
|
2017-02-27 17:14:36 +00:00
|
|
|
process.on('exit', () => preloadProcess.emit('exit'))
|
2019-11-06 01:53:03 +00:00
|
|
|
process.on('document-start', () => preloadProcess.emit('document-start'))
|
|
|
|
process.on('document-end', () => preloadProcess.emit('document-end'))
|
2017-02-27 17:14:36 +00:00
|
|
|
|
|
|
|
// This is the `require` function that will be visible to the preload script
|
2016-08-21 10:30:14 +00:00
|
|
|
function preloadRequire (module) {
|
2018-05-21 12:56:05 +00:00
|
|
|
if (loadedModules.has(module)) {
|
|
|
|
return loadedModules.get(module)
|
|
|
|
}
|
2019-03-19 19:00:41 +00:00
|
|
|
throw new Error(`module not found: ${module}`)
|
2016-08-21 10:30:14 +00:00
|
|
|
}
|
|
|
|
|
2019-01-22 01:08:16 +00:00
|
|
|
// Process command line arguments.
|
2019-03-18 19:37:06 +00:00
|
|
|
const { hasSwitch } = process.electronBinding('command_line')
|
2019-01-03 16:22:34 +00:00
|
|
|
|
2019-01-22 01:08:16 +00:00
|
|
|
const contextIsolation = hasSwitch('context-isolation')
|
2020-01-06 21:23:03 +00:00
|
|
|
const isHiddenPage = hasSwitch('hidden-page')
|
2020-02-24 20:14:11 +00:00
|
|
|
const rendererProcessReuseEnabled = hasSwitch('disable-electron-site-instance-overrides')
|
2020-01-06 21:23:03 +00:00
|
|
|
const usesNativeWindowOpen = true
|
|
|
|
|
|
|
|
// The arguments to be passed to isolated world.
|
2020-02-24 20:14:11 +00:00
|
|
|
const isolatedWorldArgs = { ipcRendererInternal, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen, rendererProcessReuseEnabled }
|
2019-01-22 01:08:16 +00:00
|
|
|
|
2018-11-21 17:56:58 +00:00
|
|
|
switch (window.location.protocol) {
|
2019-05-17 22:37:09 +00:00
|
|
|
case 'devtools:': {
|
2018-11-21 17:56:58 +00:00
|
|
|
// Override some inspector APIs.
|
|
|
|
require('@electron/internal/renderer/inspector')
|
|
|
|
break
|
|
|
|
}
|
|
|
|
case 'chrome-extension:': {
|
|
|
|
// Inject the chrome.* APIs that chrome extensions require
|
2019-07-31 21:25:41 +00:00
|
|
|
if (!process.electronBinding('features').isExtensionsEnabled()) {
|
|
|
|
require('@electron/internal/renderer/chrome-api').injectTo(window.location.hostname, window)
|
|
|
|
}
|
2018-11-21 17:56:58 +00:00
|
|
|
break
|
|
|
|
}
|
2019-03-08 00:00:28 +00:00
|
|
|
case 'chrome': {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
default: {
|
2020-01-06 21:23:03 +00:00
|
|
|
// Override default web functions.
|
|
|
|
const { windowSetup } = require('@electron/internal/renderer/window-setup')
|
2020-02-24 20:14:11 +00:00
|
|
|
windowSetup(guestInstanceId, openerId, isHiddenPage, usesNativeWindowOpen, rendererProcessReuseEnabled)
|
2020-01-06 21:23:03 +00:00
|
|
|
|
2019-03-08 00:00:28 +00:00
|
|
|
// Inject content scripts.
|
2019-07-31 21:25:41 +00:00
|
|
|
if (!process.electronBinding('features').isExtensionsEnabled()) {
|
|
|
|
require('@electron/internal/renderer/content-scripts-injector')(contentScripts)
|
|
|
|
}
|
2019-03-08 00:00:28 +00:00
|
|
|
}
|
2018-03-22 07:15:57 +00:00
|
|
|
}
|
|
|
|
|
2019-01-22 01:08:16 +00:00
|
|
|
// Load webview tag implementation.
|
2019-01-24 18:53:16 +00:00
|
|
|
if (process.isMainFrame) {
|
2019-03-07 23:26:23 +00:00
|
|
|
const { webViewInit } = require('@electron/internal/renderer/web-view/web-view-init')
|
|
|
|
webViewInit(contextIsolation, isWebViewTagEnabled, guestInstanceId)
|
2019-01-24 18:53:16 +00:00
|
|
|
}
|
2018-07-02 16:06:26 +00:00
|
|
|
|
2020-01-06 21:23:03 +00:00
|
|
|
// Pass the arguments to isolatedWorld.
|
|
|
|
if (contextIsolation) {
|
|
|
|
v8Util.setHiddenValue(global, 'isolated-world-args', isolatedWorldArgs)
|
|
|
|
}
|
|
|
|
|
2017-02-27 17:14:36 +00:00
|
|
|
// Wrap the script into a function executed in global scope. It won't have
|
|
|
|
// access to the current scope, so we'll expose a few objects as arguments:
|
|
|
|
//
|
|
|
|
// - `require`: The `preloadRequire` function
|
|
|
|
// - `process`: The `preloadProcess` object
|
2019-06-02 20:03:03 +00:00
|
|
|
// - `Buffer`: Shim of `Buffer` implementation
|
|
|
|
// - `global`: The window object, which is aliased to `global` by webpack.
|
2019-01-18 11:03:43 +00:00
|
|
|
function runPreloadScript (preloadSrc) {
|
2019-03-11 23:13:46 +00:00
|
|
|
const preloadWrapperSrc = `(function(require, process, Buffer, global, setImmediate, clearImmediate, exports) {
|
2018-03-22 07:15:57 +00:00
|
|
|
${preloadSrc}
|
|
|
|
})`
|
2016-08-21 10:30:14 +00:00
|
|
|
|
2018-07-13 02:17:11 +00:00
|
|
|
// eval in window scope
|
|
|
|
const preloadFn = binding.createPreloadScript(preloadWrapperSrc)
|
2018-09-13 16:10:51 +00:00
|
|
|
const { setImmediate, clearImmediate } = require('timers')
|
2019-01-18 11:03:43 +00:00
|
|
|
|
2019-03-11 23:13:46 +00:00
|
|
|
preloadFn(preloadRequire, preloadProcess, Buffer, global, setImmediate, clearImmediate, {})
|
2019-01-18 11:03:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-29 01:16:46 +00:00
|
|
|
for (const { preloadPath, preloadSrc, preloadError } of preloadScripts) {
|
|
|
|
try {
|
|
|
|
if (preloadSrc) {
|
|
|
|
runPreloadScript(preloadSrc)
|
|
|
|
} else if (preloadError) {
|
2019-10-10 13:59:08 +00:00
|
|
|
throw preloadError
|
2019-01-29 01:16:46 +00:00
|
|
|
}
|
|
|
|
} catch (error) {
|
|
|
|
console.error(`Unable to load preload script: ${preloadPath}`)
|
2019-07-15 04:54:33 +00:00
|
|
|
console.error(error)
|
2019-01-29 01:16:46 +00:00
|
|
|
|
2019-10-10 13:59:08 +00:00
|
|
|
ipcRendererInternal.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadPath, error)
|
2019-01-18 11:03:43 +00:00
|
|
|
}
|
2018-03-22 07:15:57 +00:00
|
|
|
}
|
2018-10-03 19:36:12 +00:00
|
|
|
|
|
|
|
// Warn about security issues
|
2019-01-24 18:53:16 +00:00
|
|
|
if (process.isMainFrame) {
|
2019-02-17 01:06:30 +00:00
|
|
|
const { securityWarnings } = require('@electron/internal/renderer/security-warnings')
|
|
|
|
securityWarnings()
|
2019-01-24 18:53:16 +00:00
|
|
|
}
|