2016-03-24 20:15:04 +00:00
|
|
|
'use strict'
|
2016-03-18 18:51:02 +00:00
|
|
|
|
2016-06-09 18:29:38 +00:00
|
|
|
const {BrowserWindow, ipcMain, webContents} = require('electron')
|
2016-11-15 08:45:34 +00:00
|
|
|
const {isSameOrigin} = process.atomBinding('v8_util')
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-06-09 17:35:48 +00:00
|
|
|
const hasProp = {}.hasOwnProperty
|
|
|
|
const frameToGuest = {}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Copy attribute of |parent| to |child| if it is not defined in |child|.
|
2016-06-09 17:35:48 +00:00
|
|
|
const mergeOptions = function (child, parent) {
|
|
|
|
let key, value
|
2016-01-12 02:40:23 +00:00
|
|
|
for (key in parent) {
|
2016-03-24 20:15:04 +00:00
|
|
|
if (!hasProp.call(parent, key)) continue
|
|
|
|
value = parent[key]
|
2016-01-12 02:40:23 +00:00
|
|
|
if (!(key in child)) {
|
|
|
|
if (typeof value === 'object') {
|
2016-03-24 20:15:04 +00:00
|
|
|
child[key] = mergeOptions({}, value)
|
2016-01-12 02:40:23 +00:00
|
|
|
} else {
|
2016-03-24 20:15:04 +00:00
|
|
|
child[key] = value
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
return child
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Merge |options| with the |embedder|'s window's options.
|
2016-06-09 17:35:48 +00:00
|
|
|
const mergeBrowserWindowOptions = function (embedder, options) {
|
2016-10-07 00:45:13 +00:00
|
|
|
if (options.webPreferences == null) {
|
|
|
|
options.webPreferences = {}
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
if (embedder.browserWindowOptions != null) {
|
2016-01-14 18:35:29 +00:00
|
|
|
// Inherit the original options if it is a BrowserWindow.
|
2016-03-24 20:15:04 +00:00
|
|
|
mergeOptions(options, embedder.browserWindowOptions)
|
2016-01-12 02:40:23 +00:00
|
|
|
} else {
|
2016-01-14 18:35:29 +00:00
|
|
|
// Or only inherit web-preferences if it is a webview.
|
2016-03-24 20:15:04 +00:00
|
|
|
mergeOptions(options.webPreferences, embedder.getWebPreferences())
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-03-30 17:51:56 +00:00
|
|
|
|
|
|
|
// Disable node integration on child window if disabled on parent window
|
|
|
|
if (embedder.getWebPreferences().nodeIntegration === false) {
|
|
|
|
options.webPreferences.nodeIntegration = false
|
|
|
|
}
|
|
|
|
|
2016-09-29 13:43:40 +00:00
|
|
|
// Sets correct openerId here to give correct options to 'new-window' event handler
|
|
|
|
options.webPreferences.openerId = embedder.id
|
|
|
|
|
2016-03-24 20:15:04 +00:00
|
|
|
return options
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-09-16 11:33:02 +00:00
|
|
|
// Setup a new guest with |embedder|
|
2016-09-29 14:01:05 +00:00
|
|
|
const setupGuest = function (embedder, frameName, guest, options) {
|
2016-01-14 18:44:21 +00:00
|
|
|
// When |embedder| is destroyed we should also destroy attached guest, and if
|
|
|
|
// guest is closed by user then we should prevent |embedder| from double
|
|
|
|
// closing guest.
|
2016-10-05 09:46:55 +00:00
|
|
|
const guestId = guest.webContents.id
|
2016-06-09 17:35:48 +00:00
|
|
|
const closedByEmbedder = function () {
|
2016-03-24 20:15:04 +00:00
|
|
|
guest.removeListener('closed', closedByUser)
|
2016-06-09 17:35:48 +00:00
|
|
|
guest.destroy()
|
2016-03-24 20:15:04 +00:00
|
|
|
}
|
2016-06-09 17:35:48 +00:00
|
|
|
const closedByUser = function () {
|
2016-04-06 23:21:26 +00:00
|
|
|
embedder.send('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_' + guestId)
|
2016-06-09 17:35:48 +00:00
|
|
|
embedder.removeListener('render-view-deleted', closedByEmbedder)
|
2016-03-24 20:15:04 +00:00
|
|
|
}
|
2016-08-16 00:13:18 +00:00
|
|
|
if (!options.webPreferences.sandbox) {
|
|
|
|
// These events should only be handled when the guest window is opened by a
|
|
|
|
// non-sandboxed renderer for two reasons:
|
|
|
|
//
|
|
|
|
// - `render-view-deleted` is emitted when the popup is closed by the user,
|
|
|
|
// and that will eventually result in NativeWindow::NotifyWindowClosed
|
|
|
|
// using a dangling pointer since `destroy()` would have been called by
|
|
|
|
// `closeByEmbedded`
|
|
|
|
// - No need to emit `ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_` since
|
|
|
|
// there's no renderer code listening to it.,
|
|
|
|
embedder.once('render-view-deleted', closedByEmbedder)
|
|
|
|
guest.once('closed', closedByUser)
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
if (frameName) {
|
2016-03-24 20:15:04 +00:00
|
|
|
frameToGuest[frameName] = guest
|
|
|
|
guest.frameName = frameName
|
|
|
|
guest.once('closed', function () {
|
2016-05-19 22:28:08 +00:00
|
|
|
delete frameToGuest[frameName]
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-10-05 09:46:55 +00:00
|
|
|
return guestId
|
2016-09-29 14:01:05 +00:00
|
|
|
}
|
2016-09-16 11:33:02 +00:00
|
|
|
|
|
|
|
// Create a new guest created by |embedder| with |options|.
|
2016-10-09 23:30:38 +00:00
|
|
|
const createGuest = function (embedder, url, frameName, options, postData) {
|
2016-09-29 14:01:05 +00:00
|
|
|
let guest = frameToGuest[frameName]
|
2016-09-16 11:33:02 +00:00
|
|
|
if (frameName && (guest != null)) {
|
|
|
|
guest.loadURL(url)
|
2016-10-05 09:46:55 +00:00
|
|
|
return guest.webContents.id
|
2016-09-16 11:33:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remember the embedder window's id.
|
|
|
|
if (options.webPreferences == null) {
|
|
|
|
options.webPreferences = {}
|
|
|
|
}
|
2016-09-29 13:43:40 +00:00
|
|
|
|
2016-09-16 11:33:02 +00:00
|
|
|
guest = new BrowserWindow(options)
|
2016-09-29 13:37:28 +00:00
|
|
|
if (!options.webContents || url !== 'about:blank') {
|
|
|
|
// We should not call `loadURL` if the window was constructed from an
|
|
|
|
// existing webContents(window.open in a sandboxed renderer) and if the url
|
|
|
|
// is not 'about:blank'.
|
|
|
|
//
|
|
|
|
// Navigating to the url when creating the window from an existing
|
|
|
|
// webContents would not be necessary(it will navigate there anyway), but
|
|
|
|
// apparently there's a bug that allows the child window to be scripted by
|
|
|
|
// the opener, even when the child window is from another origin.
|
|
|
|
//
|
|
|
|
// That's why the second condition(url !== "about:blank") is required: to
|
|
|
|
// force `OverrideSiteInstanceForNavigation` to be called and consequently
|
|
|
|
// spawn a new renderer if the new window is targeting a different origin.
|
|
|
|
//
|
|
|
|
// If the URL is "about:blank", then it is very likely that the opener just
|
|
|
|
// wants to synchronously script the popup, for example:
|
|
|
|
//
|
|
|
|
// let popup = window.open()
|
|
|
|
// popup.document.body.write('<h1>hello</h1>')
|
|
|
|
//
|
|
|
|
// The above code would not work if a navigation to "about:blank" is done
|
|
|
|
// here, since the window would be cleared of all changes in the next tick.
|
2016-10-09 23:30:38 +00:00
|
|
|
const loadOptions = {}
|
2016-11-11 17:22:45 +00:00
|
|
|
if (postData != null) {
|
2016-10-09 23:30:38 +00:00
|
|
|
loadOptions.postData = postData
|
2016-11-10 13:55:34 +00:00
|
|
|
loadOptions.extraHeaders = 'content-type: application/x-www-form-urlencoded'
|
2016-11-11 17:22:45 +00:00
|
|
|
if (postData.length > 0) {
|
2016-11-10 13:55:34 +00:00
|
|
|
const postDataFront = postData[0].bytes.toString()
|
2016-11-11 17:22:45 +00:00
|
|
|
const boundary = /^--.*[^-\r\n]/.exec(postDataFront)
|
|
|
|
if (boundary != null) {
|
2016-11-10 13:55:34 +00:00
|
|
|
loadOptions.extraHeaders = `content-type: multipart/form-data; boundary=${boundary[0].substr(2)}`
|
|
|
|
}
|
|
|
|
}
|
2016-10-10 12:58:56 +00:00
|
|
|
}
|
2016-10-09 23:30:38 +00:00
|
|
|
guest.loadURL(url, loadOptions)
|
2016-09-29 13:37:28 +00:00
|
|
|
}
|
2016-06-09 17:35:48 +00:00
|
|
|
|
2016-09-29 14:01:05 +00:00
|
|
|
return setupGuest(embedder, frameName, guest, options)
|
2016-06-09 18:29:38 +00:00
|
|
|
}
|
|
|
|
|
2016-11-23 18:23:47 +00:00
|
|
|
const getGuestWindow = function (guestContents) {
|
2016-06-09 18:29:38 +00:00
|
|
|
let guestWindow = BrowserWindow.fromWebContents(guestContents)
|
2016-06-09 20:53:36 +00:00
|
|
|
if (guestWindow == null) {
|
|
|
|
const hostContents = guestContents.hostWebContents
|
|
|
|
if (hostContents != null) {
|
|
|
|
guestWindow = BrowserWindow.fromWebContents(hostContents)
|
|
|
|
}
|
2016-06-09 18:29:38 +00:00
|
|
|
}
|
|
|
|
return guestWindow
|
2016-03-24 20:15:04 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-11-15 08:45:34 +00:00
|
|
|
// Checks whether |sender| can access the |target|:
|
|
|
|
// 1. Check whether |sender| is the parent of |target|.
|
|
|
|
// 2. Check whether |sender| has node integration, if so it is allowed to
|
|
|
|
// do anything it wants.
|
|
|
|
// 3. Check whether the origins match.
|
|
|
|
//
|
|
|
|
// However it allows a child window without node integration but with same
|
|
|
|
// origin to do anything it wants, when its opener window has node integration.
|
|
|
|
// The W3C does not have anything on this, but from my understanding of the
|
|
|
|
// security model of |window.opener|, this should be fine.
|
|
|
|
const canAccessWindow = function (sender, target) {
|
2016-11-16 15:50:24 +00:00
|
|
|
return (target.getWebPreferences().openerId === sender.id) ||
|
2016-11-15 08:45:34 +00:00
|
|
|
(sender.getWebPreferences().nodeIntegration === true) ||
|
|
|
|
isSameOrigin(sender.getURL(), target.getURL())
|
|
|
|
}
|
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Routed window.open messages.
|
2016-10-09 23:30:38 +00:00
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_OPEN', function (event, url, frameName,
|
|
|
|
disposition, options,
|
|
|
|
additionalFeatures, postData) {
|
2016-03-24 20:15:04 +00:00
|
|
|
options = mergeBrowserWindowOptions(event.sender, options)
|
2016-09-15 13:37:35 +00:00
|
|
|
event.sender.emit('new-window', event, url, frameName, disposition, options, additionalFeatures)
|
2016-09-29 12:41:35 +00:00
|
|
|
const newGuest = event.newGuest
|
2016-01-12 02:40:23 +00:00
|
|
|
if ((event.sender.isGuest() && !event.sender.allowPopups) || event.defaultPrevented) {
|
2016-09-29 14:01:05 +00:00
|
|
|
if (newGuest !== undefined && newGuest !== null) {
|
|
|
|
event.returnValue = setupGuest(event.sender, frameName, newGuest, options)
|
2016-09-29 12:41:35 +00:00
|
|
|
} else {
|
2016-09-16 11:33:02 +00:00
|
|
|
event.returnValue = null
|
2016-09-29 12:41:35 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
} else {
|
2016-10-09 23:30:38 +00:00
|
|
|
event.returnValue = createGuest(event.sender, url, frameName, options, postData)
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-04-06 23:21:26 +00:00
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', function (event, guestId) {
|
2016-11-23 18:23:47 +00:00
|
|
|
const guestContents = webContents.fromId(guestId)
|
|
|
|
if (guestContents == null) return
|
2016-11-16 01:41:15 +00:00
|
|
|
|
2016-11-23 18:23:47 +00:00
|
|
|
if (!canAccessWindow(event.sender, guestContents)) {
|
2016-11-16 00:51:43 +00:00
|
|
|
console.error(`Blocked ${event.sender.getURL()} from closing its opener.`)
|
2016-11-23 18:23:47 +00:00
|
|
|
return
|
2016-11-15 08:45:34 +00:00
|
|
|
}
|
2016-11-23 18:23:47 +00:00
|
|
|
|
|
|
|
const guestWindow = getGuestWindow(guestContents)
|
|
|
|
if (guestWindow != null) guestWindow.destroy()
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-04-06 23:21:26 +00:00
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_METHOD', function (event, guestId, method, ...args) {
|
2016-11-23 18:23:47 +00:00
|
|
|
const guestContents = webContents.fromId(guestId)
|
|
|
|
if (guestContents == null) {
|
|
|
|
event.returnValue = null
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!canAccessWindow(event.sender, guestContents)) {
|
|
|
|
console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`)
|
2016-11-16 01:41:15 +00:00
|
|
|
event.returnValue = null
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-11-23 18:23:47 +00:00
|
|
|
const guestWindow = getGuestWindow(guestContents)
|
|
|
|
if (guestWindow != null) {
|
2016-11-15 08:45:34 +00:00
|
|
|
event.returnValue = guestWindow[method].apply(guestWindow, args)
|
|
|
|
} else {
|
|
|
|
event.returnValue = null
|
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-04-06 23:21:26 +00:00
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', function (event, guestId, message, targetOrigin, sourceOrigin) {
|
2016-06-09 18:29:38 +00:00
|
|
|
const guestContents = webContents.fromId(guestId)
|
|
|
|
if (guestContents == null) return
|
2016-06-09 17:35:48 +00:00
|
|
|
|
2016-11-15 08:45:34 +00:00
|
|
|
// The W3C does not seem to have word on how postMessage should work when the
|
|
|
|
// origins do not match, so we do not do |canAccessWindow| check here since
|
2016-11-16 01:41:15 +00:00
|
|
|
// postMessage across origins is useful and not harmful.
|
2016-06-09 18:29:38 +00:00
|
|
|
if (guestContents.getURL().indexOf(targetOrigin) === 0 || targetOrigin === '*') {
|
|
|
|
const sourceId = event.sender.id
|
|
|
|
guestContents.send('ELECTRON_GUEST_WINDOW_POSTMESSAGE', sourceId, message, sourceOrigin)
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-04-06 23:21:26 +00:00
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', function (event, guestId, method, ...args) {
|
2016-06-09 18:29:38 +00:00
|
|
|
const guestContents = webContents.fromId(guestId)
|
2016-11-16 01:41:15 +00:00
|
|
|
if (guestContents == null) return
|
|
|
|
|
|
|
|
if (canAccessWindow(event.sender, guestContents)) {
|
2016-11-15 08:45:34 +00:00
|
|
|
guestContents[method].apply(guestContents, args)
|
2016-11-16 00:51:43 +00:00
|
|
|
} else {
|
2016-11-16 01:41:15 +00:00
|
|
|
console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`)
|
2016-11-15 08:45:34 +00:00
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-11-25 18:03:47 +00:00
|
|
|
|
|
|
|
ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD_SYNC', function (event, guestId, method, ...args) {
|
|
|
|
const guestContents = webContents.fromId(guestId)
|
|
|
|
if (guestContents == null) {
|
|
|
|
event.returnValue = null
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if (canAccessWindow(event.sender, guestContents)) {
|
|
|
|
event.returnValue = guestContents[method].apply(guestContents, args)
|
|
|
|
} else {
|
|
|
|
console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`)
|
|
|
|
event.returnValue = null
|
|
|
|
}
|
|
|
|
})
|