2018-09-22 12:28:50 +00:00
|
|
|
'use strict'
|
|
|
|
|
|
2018-10-06 11:48:00 +00:00
|
|
|
const { app, webContents, BrowserWindow } = require('electron')
|
2018-09-13 16:10:51 +00:00
|
|
|
const { getAllWebContents } = process.atomBinding('web_contents')
|
2016-06-14 00:01:13 +00:00
|
|
|
const renderProcessPreferences = process.atomBinding('render_process_preferences').forAllWebContents()
|
2019-02-04 22:49:53 +00:00
|
|
|
const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
|
2019-02-08 20:07:09 +00:00
|
|
|
const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
|
2016-05-27 00:47:37 +00:00
|
|
|
|
2018-09-13 16:10:51 +00:00
|
|
|
const { Buffer } = require('buffer')
|
2016-03-24 20:15:04 +00:00
|
|
|
const fs = require('fs')
|
|
|
|
|
const path = require('path')
|
|
|
|
|
const url = require('url')
|
2019-02-10 18:38:14 +00:00
|
|
|
const util = require('util')
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-05-28 08:51:49 +00:00
|
|
|
// Mapping between extensionId(hostname) and manifest.
|
2018-09-13 16:10:51 +00:00
|
|
|
const manifestMap = {} // extensionId => manifest
|
|
|
|
|
const manifestNameMap = {} // name => manifest
|
2017-07-03 18:01:08 +00:00
|
|
|
const devToolsExtensionNames = new Set()
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-05-29 02:57:20 +00:00
|
|
|
const generateExtensionIdFromName = function (name) {
|
|
|
|
|
return name.replace(/[\W_]+/g, '-').toLowerCase()
|
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-06-14 16:30:06 +00:00
|
|
|
const isWindowOrWebView = function (webContents) {
|
|
|
|
|
const type = webContents.getType()
|
|
|
|
|
return type === 'window' || type === 'webview'
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-28 08:51:49 +00:00
|
|
|
// Create or get manifest object from |srcDirectory|.
|
2016-05-26 07:57:23 +00:00
|
|
|
const getManifestFromPath = function (srcDirectory) {
|
2016-06-06 01:30:49 +00:00
|
|
|
let manifest
|
2016-06-09 16:45:02 +00:00
|
|
|
let manifestContent
|
2016-06-06 01:30:49 +00:00
|
|
|
|
|
|
|
|
try {
|
2016-06-09 16:45:02 +00:00
|
|
|
manifestContent = fs.readFileSync(path.join(srcDirectory, 'manifest.json'))
|
|
|
|
|
} catch (readError) {
|
|
|
|
|
console.warn(`Reading ${path.join(srcDirectory, 'manifest.json')} failed.`)
|
|
|
|
|
console.warn(readError.stack || readError)
|
|
|
|
|
throw readError
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
manifest = JSON.parse(manifestContent)
|
|
|
|
|
} catch (parseError) {
|
|
|
|
|
console.warn(`Parsing ${path.join(srcDirectory, 'manifest.json')} failed.`)
|
|
|
|
|
console.warn(parseError.stack || parseError)
|
|
|
|
|
throw parseError
|
2016-06-06 01:30:49 +00:00
|
|
|
}
|
|
|
|
|
|
2016-05-28 08:51:49 +00:00
|
|
|
if (!manifestNameMap[manifest.name]) {
|
2016-05-29 02:57:20 +00:00
|
|
|
const extensionId = generateExtensionIdFromName(manifest.name)
|
2016-05-28 08:51:49 +00:00
|
|
|
manifestMap[extensionId] = manifestNameMap[manifest.name] = manifest
|
2016-05-26 09:58:18 +00:00
|
|
|
Object.assign(manifest, {
|
|
|
|
|
srcDirectory: srcDirectory,
|
2016-05-28 08:51:49 +00:00
|
|
|
extensionId: extensionId,
|
2016-05-26 09:58:18 +00:00
|
|
|
// We can not use 'file://' directly because all resources in the extension
|
|
|
|
|
// will be treated as relative to the root in Chrome.
|
|
|
|
|
startPage: url.format({
|
|
|
|
|
protocol: 'chrome-extension',
|
|
|
|
|
slashes: true,
|
2016-05-28 08:51:49 +00:00
|
|
|
hostname: extensionId,
|
2016-05-26 09:58:18 +00:00
|
|
|
pathname: manifest.devtools_page
|
|
|
|
|
})
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
2016-05-26 07:57:23 +00:00
|
|
|
return manifest
|
2016-06-03 21:30:55 +00:00
|
|
|
} else if (manifest && manifest.name) {
|
2016-06-09 17:08:21 +00:00
|
|
|
console.warn(`Attempted to load extension "${manifest.name}" that has already been loaded.`)
|
2017-07-03 18:01:08 +00:00
|
|
|
return manifest
|
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-05-26 09:58:18 +00:00
|
|
|
// Manage the background pages.
|
2016-05-26 22:43:23 +00:00
|
|
|
const backgroundPages = {}
|
2016-05-26 09:58:18 +00:00
|
|
|
|
|
|
|
|
const startBackgroundPages = function (manifest) {
|
2016-05-28 08:51:49 +00:00
|
|
|
if (backgroundPages[manifest.extensionId] || !manifest.background) return
|
2016-05-26 09:58:18 +00:00
|
|
|
|
2016-06-30 07:45:03 +00:00
|
|
|
let html
|
2016-07-01 15:05:00 +00:00
|
|
|
let name
|
2016-06-30 07:45:03 +00:00
|
|
|
if (manifest.background.page) {
|
2016-07-01 15:05:00 +00:00
|
|
|
name = manifest.background.page
|
2016-06-30 07:45:03 +00:00
|
|
|
html = fs.readFileSync(path.join(manifest.srcDirectory, manifest.background.page))
|
|
|
|
|
} else {
|
2016-07-01 15:05:00 +00:00
|
|
|
name = '_generated_background_page.html'
|
2016-06-30 07:45:03 +00:00
|
|
|
const scripts = manifest.background.scripts.map((name) => {
|
|
|
|
|
return `<script src="${name}"></script>`
|
|
|
|
|
}).join('')
|
2017-06-12 08:57:42 +00:00
|
|
|
html = Buffer.from(`<html><body>${scripts}</body></html>`)
|
2016-06-30 07:45:03 +00:00
|
|
|
}
|
2016-05-26 09:58:18 +00:00
|
|
|
|
2016-05-29 01:46:48 +00:00
|
|
|
const contents = webContents.create({
|
2016-07-13 07:22:55 +00:00
|
|
|
partition: 'persist:__chrome_extension',
|
2016-06-16 01:54:28 +00:00
|
|
|
isBackgroundPage: true,
|
2019-02-11 20:42:37 +00:00
|
|
|
commandLineSwitches: ['--background-page'],
|
2019-02-15 09:40:32 +00:00
|
|
|
sandbox: true,
|
2019-02-11 20:42:37 +00:00
|
|
|
enableRemoteModule: false
|
2016-05-29 01:46:48 +00:00
|
|
|
})
|
2016-07-01 15:05:00 +00:00
|
|
|
backgroundPages[manifest.extensionId] = { html: html, webContents: contents, name: name }
|
2016-05-26 09:58:18 +00:00
|
|
|
contents.loadURL(url.format({
|
|
|
|
|
protocol: 'chrome-extension',
|
|
|
|
|
slashes: true,
|
2016-05-28 08:51:49 +00:00
|
|
|
hostname: manifest.extensionId,
|
2016-07-01 15:05:00 +00:00
|
|
|
pathname: name
|
2016-05-26 09:58:18 +00:00
|
|
|
}))
|
2016-05-26 07:34:57 +00:00
|
|
|
}
|
|
|
|
|
|
2016-05-27 00:55:59 +00:00
|
|
|
const removeBackgroundPages = function (manifest) {
|
2016-05-28 08:51:49 +00:00
|
|
|
if (!backgroundPages[manifest.extensionId]) return
|
2016-05-27 00:55:59 +00:00
|
|
|
|
2016-05-28 08:51:49 +00:00
|
|
|
backgroundPages[manifest.extensionId].webContents.destroy()
|
|
|
|
|
delete backgroundPages[manifest.extensionId]
|
2016-05-27 00:55:59 +00:00
|
|
|
}
|
|
|
|
|
|
2016-06-16 19:07:59 +00:00
|
|
|
const sendToBackgroundPages = function (...args) {
|
2018-02-06 04:03:28 +00:00
|
|
|
for (const page of Object.values(backgroundPages)) {
|
2018-10-06 11:48:00 +00:00
|
|
|
page.webContents._sendInternalToAll(...args)
|
2016-05-29 02:50:14 +00:00
|
|
|
}
|
2016-06-16 19:07:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Dispatch web contents events to Chrome APIs
|
|
|
|
|
const hookWebContentsEvents = function (webContents) {
|
|
|
|
|
const tabId = webContents.id
|
|
|
|
|
|
|
|
|
|
sendToBackgroundPages('CHROME_TABS_ONCREATED')
|
|
|
|
|
|
|
|
|
|
webContents.on('will-navigate', (event, url) => {
|
|
|
|
|
sendToBackgroundPages('CHROME_WEBNAVIGATION_ONBEFORENAVIGATE', {
|
|
|
|
|
frameId: 0,
|
|
|
|
|
parentFrameId: -1,
|
2016-09-06 01:28:40 +00:00
|
|
|
processId: webContents.getProcessId(),
|
2016-06-16 19:07:59 +00:00
|
|
|
tabId: tabId,
|
|
|
|
|
timeStamp: Date.now(),
|
|
|
|
|
url: url
|
|
|
|
|
})
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
webContents.on('did-navigate', (event, url) => {
|
|
|
|
|
sendToBackgroundPages('CHROME_WEBNAVIGATION_ONCOMPLETED', {
|
|
|
|
|
frameId: 0,
|
|
|
|
|
parentFrameId: -1,
|
2016-09-06 01:28:40 +00:00
|
|
|
processId: webContents.getProcessId(),
|
2016-06-16 19:07:59 +00:00
|
|
|
tabId: tabId,
|
|
|
|
|
timeStamp: Date.now(),
|
|
|
|
|
url: url
|
|
|
|
|
})
|
|
|
|
|
})
|
2016-05-29 02:50:14 +00:00
|
|
|
|
2016-06-07 17:10:56 +00:00
|
|
|
webContents.once('destroyed', () => {
|
2016-06-16 19:07:59 +00:00
|
|
|
sendToBackgroundPages('CHROME_TABS_ONREMOVED', tabId)
|
2016-05-29 02:50:14 +00:00
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-28 01:26:41 +00:00
|
|
|
// Handle the chrome.* API messages.
|
2016-05-28 03:07:08 +00:00
|
|
|
let nextId = 0
|
|
|
|
|
|
2019-02-04 22:49:53 +00:00
|
|
|
ipcMainInternal.on('CHROME_RUNTIME_CONNECT', function (event, extensionId, connectInfo) {
|
2016-05-28 08:51:49 +00:00
|
|
|
const page = backgroundPages[extensionId]
|
2016-05-28 01:26:41 +00:00
|
|
|
if (!page) {
|
2016-06-14 22:39:07 +00:00
|
|
|
console.error(`Connect to unknown extension ${extensionId}`)
|
2016-05-28 01:26:41 +00:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-28 03:07:08 +00:00
|
|
|
const portId = ++nextId
|
2018-09-13 16:10:51 +00:00
|
|
|
event.returnValue = { tabId: page.webContents.id, portId: portId }
|
2016-05-28 03:07:08 +00:00
|
|
|
|
|
|
|
|
event.sender.once('render-view-deleted', () => {
|
2016-05-28 12:13:00 +00:00
|
|
|
if (page.webContents.isDestroyed()) return
|
2018-10-06 11:48:00 +00:00
|
|
|
page.webContents._sendInternalToAll(`CHROME_PORT_DISCONNECT_${portId}`)
|
2016-05-28 03:07:08 +00:00
|
|
|
})
|
2018-10-06 11:48:00 +00:00
|
|
|
page.webContents._sendInternalToAll(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, event.sender.id, portId, connectInfo)
|
2016-05-28 03:07:08 +00:00
|
|
|
})
|
|
|
|
|
|
2019-02-13 17:16:12 +00:00
|
|
|
ipcMainUtils.handleSync('CHROME_EXTENSION_MANIFEST', function (event, extensionId) {
|
|
|
|
|
const manifest = manifestMap[extensionId]
|
|
|
|
|
if (!manifest) {
|
|
|
|
|
throw new Error(`Invalid extensionId: ${extensionId}`)
|
|
|
|
|
}
|
|
|
|
|
return manifest
|
|
|
|
|
})
|
|
|
|
|
|
2016-11-15 10:30:40 +00:00
|
|
|
let resultID = 1
|
2019-02-04 22:49:53 +00:00
|
|
|
ipcMainInternal.on('CHROME_RUNTIME_SENDMESSAGE', function (event, extensionId, message, originResultID) {
|
2016-05-28 12:23:43 +00:00
|
|
|
const page = backgroundPages[extensionId]
|
|
|
|
|
if (!page) {
|
2016-06-14 22:39:07 +00:00
|
|
|
console.error(`Connect to unknown extension ${extensionId}`)
|
2016-05-28 12:23:43 +00:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-06 11:48:00 +00:00
|
|
|
page.webContents._sendInternalToAll(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, event.sender.id, message, resultID)
|
2019-02-14 16:07:55 +00:00
|
|
|
ipcMainInternal.once(`CHROME_RUNTIME_ONMESSAGE_RESULT_${resultID}`, (resultEvent, result) => {
|
2019-01-22 19:24:46 +00:00
|
|
|
event._replyInternal(`CHROME_RUNTIME_SENDMESSAGE_RESULT_${originResultID}`, result)
|
2016-11-15 10:30:40 +00:00
|
|
|
})
|
|
|
|
|
resultID++
|
2016-05-28 12:23:43 +00:00
|
|
|
})
|
|
|
|
|
|
2019-02-04 22:49:53 +00:00
|
|
|
ipcMainInternal.on('CHROME_TABS_SEND_MESSAGE', function (event, tabId, extensionId, isBackgroundPage, message, originResultID) {
|
2016-05-29 01:46:48 +00:00
|
|
|
const contents = webContents.fromId(tabId)
|
|
|
|
|
if (!contents) {
|
2016-06-14 22:39:07 +00:00
|
|
|
console.error(`Sending message to unknown tab ${tabId}`)
|
2016-05-29 01:46:48 +00:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const senderTabId = isBackgroundPage ? null : event.sender.id
|
|
|
|
|
|
2018-10-06 11:48:00 +00:00
|
|
|
contents._sendInternalToAll(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, senderTabId, message, resultID)
|
2019-02-14 16:07:55 +00:00
|
|
|
ipcMainInternal.once(`CHROME_RUNTIME_ONMESSAGE_RESULT_${resultID}`, (resultEvent, result) => {
|
2019-01-22 19:24:46 +00:00
|
|
|
event._replyInternal(`CHROME_TABS_SEND_MESSAGE_RESULT_${originResultID}`, result)
|
2016-11-15 10:30:40 +00:00
|
|
|
})
|
|
|
|
|
resultID++
|
2016-05-29 01:46:48 +00:00
|
|
|
})
|
|
|
|
|
|
2019-02-08 20:07:09 +00:00
|
|
|
const getLanguage = () => {
|
|
|
|
|
return app.getLocale().replace(/-.*$/, '').toLowerCase()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const getMessagesPath = (extensionId) => {
|
|
|
|
|
const metadata = manifestMap[extensionId]
|
|
|
|
|
if (!metadata) {
|
|
|
|
|
throw new Error(`Invalid extensionId: ${extensionId}`)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const localesDirectory = path.join(metadata.srcDirectory, '_locales')
|
|
|
|
|
const language = getLanguage()
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
const filename = path.join(localesDirectory, language, 'messages.json')
|
|
|
|
|
fs.accessSync(filename, fs.constants.R_OK)
|
|
|
|
|
return filename
|
|
|
|
|
} catch (err) {
|
|
|
|
|
const defaultLocale = metadata.default_locale || 'en'
|
|
|
|
|
return path.join(localesDirectory, defaultLocale, 'messages.json')
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ipcMainUtils.handleSync('CHROME_GET_MESSAGES', function (event, extensionId) {
|
|
|
|
|
const messagesPath = getMessagesPath(extensionId)
|
|
|
|
|
return fs.readFileSync(messagesPath)
|
|
|
|
|
})
|
|
|
|
|
|
2019-02-10 18:38:14 +00:00
|
|
|
const validStorageTypes = new Set(['sync', 'local'])
|
|
|
|
|
|
|
|
|
|
const getChromeStoragePath = (storageType, extensionId) => {
|
|
|
|
|
if (!validStorageTypes.has(storageType)) {
|
|
|
|
|
throw new Error(`Invalid storageType: ${storageType}`)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!manifestMap[extensionId]) {
|
|
|
|
|
throw new Error(`Invalid extensionId: ${extensionId}`)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return path.join(app.getPath('userData'), `/Chrome Storage/${extensionId}-${storageType}.json`)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const mkdirp = util.promisify((dir, callback) => {
|
|
|
|
|
fs.mkdir(dir, (error) => {
|
|
|
|
|
if (error && error.code === 'ENOENT') {
|
|
|
|
|
mkdirp(path.dirname(dir), (error) => {
|
|
|
|
|
if (!error) {
|
|
|
|
|
mkdirp(dir, callback)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
} else if (error && error.code === 'EEXIST') {
|
|
|
|
|
callback(null)
|
|
|
|
|
} else {
|
|
|
|
|
callback(error)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
const readFile = util.promisify(fs.readFile)
|
|
|
|
|
const writeFile = util.promisify(fs.writeFile)
|
|
|
|
|
|
|
|
|
|
ipcMainUtils.handle('CHROME_STORAGE_READ', async function (event, storageType, extensionId) {
|
|
|
|
|
const filePath = getChromeStoragePath(storageType, extensionId)
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
return await readFile(filePath, 'utf8')
|
|
|
|
|
} catch (error) {
|
|
|
|
|
if (error.code === 'ENOENT') {
|
|
|
|
|
return null
|
|
|
|
|
} else {
|
|
|
|
|
throw error
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
ipcMainUtils.handle('CHROME_STORAGE_WRITE', async function (event, storageType, extensionId, data) {
|
|
|
|
|
const filePath = getChromeStoragePath(storageType, extensionId)
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
await mkdirp(path.dirname(filePath))
|
|
|
|
|
} catch (error) {
|
|
|
|
|
// we just ignore the errors of mkdir or mkdirp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return writeFile(filePath, data, 'utf8')
|
|
|
|
|
})
|
|
|
|
|
|
2018-12-11 09:45:46 +00:00
|
|
|
const isChromeExtension = function (pageURL) {
|
|
|
|
|
const { protocol } = url.parse(pageURL)
|
|
|
|
|
return protocol === 'chrome-extension:'
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-04 22:49:53 +00:00
|
|
|
ipcMainInternal.on('CHROME_TABS_EXECUTESCRIPT', function (event, requestId, tabId, extensionId, details) {
|
2018-12-11 09:45:46 +00:00
|
|
|
const pageURL = event.sender._getURL()
|
|
|
|
|
if (!isChromeExtension(pageURL)) {
|
|
|
|
|
console.error(`Blocked ${pageURL} from calling chrome.tabs.executeScript()`)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-29 01:46:48 +00:00
|
|
|
const contents = webContents.fromId(tabId)
|
2016-05-28 07:41:12 +00:00
|
|
|
if (!contents) {
|
2016-06-14 22:39:07 +00:00
|
|
|
console.error(`Sending message to unknown tab ${tabId}`)
|
2016-05-28 07:41:12 +00:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let code, url
|
|
|
|
|
if (details.file) {
|
2016-05-28 08:51:49 +00:00
|
|
|
const manifest = manifestMap[extensionId]
|
2016-05-28 07:41:12 +00:00
|
|
|
code = String(fs.readFileSync(path.join(manifest.srcDirectory, details.file)))
|
2016-05-28 08:51:49 +00:00
|
|
|
url = `chrome-extension://${extensionId}${details.file}`
|
2016-05-28 07:41:12 +00:00
|
|
|
} else {
|
|
|
|
|
code = details.code
|
2016-05-28 08:51:49 +00:00
|
|
|
url = `chrome-extension://${extensionId}/${String(Math.random()).substr(2, 8)}.js`
|
2016-05-28 07:41:12 +00:00
|
|
|
}
|
|
|
|
|
|
2018-10-06 11:48:00 +00:00
|
|
|
contents._sendInternal('CHROME_TABS_EXECUTESCRIPT', event.sender.id, requestId, extensionId, url, code)
|
2016-05-28 07:41:12 +00:00
|
|
|
})
|
|
|
|
|
|
2016-05-27 00:47:37 +00:00
|
|
|
// Transfer the content scripts to renderer.
|
|
|
|
|
const contentScripts = {}
|
|
|
|
|
|
|
|
|
|
const injectContentScripts = function (manifest) {
|
|
|
|
|
if (contentScripts[manifest.name] || !manifest.content_scripts) return
|
|
|
|
|
|
|
|
|
|
const readArrayOfFiles = function (relativePath) {
|
2016-05-28 06:37:44 +00:00
|
|
|
return {
|
2016-05-28 08:51:49 +00:00
|
|
|
url: `chrome-extension://${manifest.extensionId}/${relativePath}`,
|
2016-05-28 06:37:44 +00:00
|
|
|
code: String(fs.readFileSync(path.join(manifest.srcDirectory, relativePath)))
|
|
|
|
|
}
|
2016-05-27 00:47:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const contentScriptToEntry = function (script) {
|
|
|
|
|
return {
|
|
|
|
|
matches: script.matches,
|
2017-07-20 18:24:39 +00:00
|
|
|
js: script.js ? script.js.map(readArrayOfFiles) : [],
|
|
|
|
|
css: script.css ? script.css.map(readArrayOfFiles) : [],
|
2016-05-27 01:29:57 +00:00
|
|
|
runAt: script.run_at || 'document_idle'
|
2016-05-27 00:47:37 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
const entry = {
|
2016-05-28 08:51:49 +00:00
|
|
|
extensionId: manifest.extensionId,
|
2016-05-27 00:47:37 +00:00
|
|
|
contentScripts: manifest.content_scripts.map(contentScriptToEntry)
|
|
|
|
|
}
|
|
|
|
|
contentScripts[manifest.name] = renderProcessPreferences.addEntry(entry)
|
|
|
|
|
} catch (e) {
|
|
|
|
|
console.error('Failed to read content scripts', e)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-27 00:55:59 +00:00
|
|
|
const removeContentScripts = function (manifest) {
|
|
|
|
|
if (!contentScripts[manifest.name]) return
|
|
|
|
|
|
|
|
|
|
renderProcessPreferences.removeEntry(contentScripts[manifest.name])
|
|
|
|
|
delete contentScripts[manifest.name]
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-26 07:57:23 +00:00
|
|
|
// Transfer the |manifest| to a format that can be recognized by the
|
|
|
|
|
// |DevToolsAPI.addExtensions|.
|
|
|
|
|
const manifestToExtensionInfo = function (manifest) {
|
|
|
|
|
return {
|
|
|
|
|
startPage: manifest.startPage,
|
|
|
|
|
srcDirectory: manifest.srcDirectory,
|
|
|
|
|
name: manifest.name,
|
|
|
|
|
exposeExperimentalAPIs: true
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-26 09:58:18 +00:00
|
|
|
// Load the extensions for the window.
|
2016-05-28 08:51:49 +00:00
|
|
|
const loadExtension = function (manifest) {
|
|
|
|
|
startBackgroundPages(manifest)
|
|
|
|
|
injectContentScripts(manifest)
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-26 09:58:18 +00:00
|
|
|
const loadDevToolsExtensions = function (win, manifests) {
|
|
|
|
|
if (!win.devToolsWebContents) return
|
|
|
|
|
|
2016-05-28 08:51:49 +00:00
|
|
|
manifests.forEach(loadExtension)
|
|
|
|
|
|
2016-05-26 09:58:18 +00:00
|
|
|
const extensionInfoArray = manifests.map(manifestToExtensionInfo)
|
2017-06-30 22:47:41 +00:00
|
|
|
extensionInfoArray.forEach((extension) => {
|
|
|
|
|
win.devToolsWebContents._grantOriginAccess(extension.startPage)
|
|
|
|
|
})
|
2016-05-26 09:58:18 +00:00
|
|
|
win.devToolsWebContents.executeJavaScript(`DevToolsAPI.addExtensions(${JSON.stringify(extensionInfoArray)})`)
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-13 15:59:03 +00:00
|
|
|
app.on('web-contents-created', function (event, webContents) {
|
2016-06-14 16:30:06 +00:00
|
|
|
if (!isWindowOrWebView(webContents)) return
|
2016-06-08 18:41:14 +00:00
|
|
|
|
2016-06-16 19:07:59 +00:00
|
|
|
hookWebContentsEvents(webContents)
|
2016-06-08 18:15:41 +00:00
|
|
|
webContents.on('devtools-opened', function () {
|
2018-02-06 04:03:28 +00:00
|
|
|
loadDevToolsExtensions(webContents, Object.values(manifestMap))
|
2016-06-08 18:15:41 +00:00
|
|
|
})
|
|
|
|
|
})
|
|
|
|
|
|
2016-07-12 13:57:38 +00:00
|
|
|
// The chrome-extension: can map a extension URL request to real file path.
|
|
|
|
|
const chromeExtensionHandler = function (request, callback) {
|
|
|
|
|
const parsed = url.parse(request.url)
|
|
|
|
|
if (!parsed.hostname || !parsed.path) return callback()
|
|
|
|
|
|
|
|
|
|
const manifest = manifestMap[parsed.hostname]
|
|
|
|
|
if (!manifest) return callback()
|
|
|
|
|
|
|
|
|
|
const page = backgroundPages[parsed.hostname]
|
|
|
|
|
if (page && parsed.path === `/${page.name}`) {
|
2017-11-23 21:53:03 +00:00
|
|
|
// Disabled due to false positive in StandardJS
|
|
|
|
|
// eslint-disable-next-line standard/no-callback-literal
|
2016-07-12 13:57:38 +00:00
|
|
|
return callback({
|
|
|
|
|
mimeType: 'text/html',
|
|
|
|
|
data: page.html
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fs.readFile(path.join(manifest.srcDirectory, parsed.path), function (err, content) {
|
|
|
|
|
if (err) {
|
2017-11-23 21:53:03 +00:00
|
|
|
// Disabled due to false positive in StandardJS
|
|
|
|
|
// eslint-disable-next-line standard/no-callback-literal
|
2018-09-13 16:10:51 +00:00
|
|
|
return callback(-6) // FILE_NOT_FOUND
|
2016-07-12 13:57:38 +00:00
|
|
|
} else {
|
|
|
|
|
return callback(content)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
app.on('session-created', function (ses) {
|
|
|
|
|
ses.protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler, function (error) {
|
|
|
|
|
if (error) {
|
|
|
|
|
console.error(`Unable to register chrome-extension protocol: ${error}`)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
})
|
|
|
|
|
|
2016-05-26 07:34:57 +00:00
|
|
|
// The persistent path of "DevTools Extensions" preference file.
|
2017-07-03 18:01:08 +00:00
|
|
|
let loadedDevToolsExtensionsPath = null
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-03-24 20:15:04 +00:00
|
|
|
app.on('will-quit', function () {
|
2016-01-12 02:40:23 +00:00
|
|
|
try {
|
2017-07-03 18:01:08 +00:00
|
|
|
const loadedDevToolsExtensions = Array.from(devToolsExtensionNames)
|
|
|
|
|
.map(name => manifestNameMap[name].srcDirectory)
|
|
|
|
|
if (loadedDevToolsExtensions.length > 0) {
|
2016-02-04 01:12:09 +00:00
|
|
|
try {
|
2017-07-03 18:01:08 +00:00
|
|
|
fs.mkdirSync(path.dirname(loadedDevToolsExtensionsPath))
|
2016-02-04 01:12:09 +00:00
|
|
|
} catch (error) {
|
|
|
|
|
// Ignore error
|
|
|
|
|
}
|
2017-07-03 18:01:08 +00:00
|
|
|
fs.writeFileSync(loadedDevToolsExtensionsPath, JSON.stringify(loadedDevToolsExtensions))
|
2016-02-04 01:12:09 +00:00
|
|
|
} else {
|
2017-07-03 18:01:08 +00:00
|
|
|
fs.unlinkSync(loadedDevToolsExtensionsPath)
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-01-19 22:49:40 +00:00
|
|
|
} catch (error) {
|
|
|
|
|
// Ignore error
|
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-01-14 18:35:29 +00:00
|
|
|
// We can not use protocol or BrowserWindow until app is ready.
|
2016-03-24 20:15:04 +00:00
|
|
|
app.once('ready', function () {
|
2016-05-28 01:39:11 +00:00
|
|
|
// The public API to add/remove extensions.
|
2017-07-03 18:01:08 +00:00
|
|
|
BrowserWindow.addExtension = function (srcDirectory) {
|
2016-05-26 07:57:23 +00:00
|
|
|
const manifest = getManifestFromPath(srcDirectory)
|
|
|
|
|
if (manifest) {
|
2016-06-17 21:53:51 +00:00
|
|
|
loadExtension(manifest)
|
2016-06-07 18:02:57 +00:00
|
|
|
for (const webContents of getAllWebContents()) {
|
2016-06-14 16:30:06 +00:00
|
|
|
if (isWindowOrWebView(webContents)) {
|
2016-06-08 18:41:14 +00:00
|
|
|
loadDevToolsExtensions(webContents, [manifest])
|
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-05-26 07:57:23 +00:00
|
|
|
return manifest.name
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
}
|
2016-06-07 16:50:36 +00:00
|
|
|
|
2017-07-03 18:01:08 +00:00
|
|
|
BrowserWindow.removeExtension = function (name) {
|
2016-05-28 08:51:49 +00:00
|
|
|
const manifest = manifestNameMap[name]
|
2016-05-27 00:55:59 +00:00
|
|
|
if (!manifest) return
|
|
|
|
|
|
|
|
|
|
removeBackgroundPages(manifest)
|
|
|
|
|
removeContentScripts(manifest)
|
2016-05-28 08:51:49 +00:00
|
|
|
delete manifestMap[manifest.extensionId]
|
|
|
|
|
delete manifestNameMap[name]
|
2016-03-24 20:15:04 +00:00
|
|
|
}
|
2016-06-09 17:04:02 +00:00
|
|
|
|
2017-07-03 18:01:08 +00:00
|
|
|
BrowserWindow.getExtensions = function () {
|
2016-06-10 16:24:00 +00:00
|
|
|
const extensions = {}
|
|
|
|
|
Object.keys(manifestNameMap).forEach(function (name) {
|
|
|
|
|
const manifest = manifestNameMap[name]
|
2018-09-13 16:10:51 +00:00
|
|
|
extensions[name] = { name: manifest.name, version: manifest.version }
|
2016-06-10 16:24:00 +00:00
|
|
|
})
|
|
|
|
|
return extensions
|
2016-06-09 17:04:02 +00:00
|
|
|
}
|
2017-07-03 18:01:08 +00:00
|
|
|
|
|
|
|
|
BrowserWindow.addDevToolsExtension = function (srcDirectory) {
|
|
|
|
|
const manifestName = BrowserWindow.addExtension(srcDirectory)
|
|
|
|
|
if (manifestName) {
|
|
|
|
|
devToolsExtensionNames.add(manifestName)
|
|
|
|
|
}
|
|
|
|
|
return manifestName
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BrowserWindow.removeDevToolsExtension = function (name) {
|
|
|
|
|
BrowserWindow.removeExtension(name)
|
|
|
|
|
devToolsExtensionNames.delete(name)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BrowserWindow.getDevToolsExtensions = function () {
|
|
|
|
|
const extensions = BrowserWindow.getExtensions()
|
|
|
|
|
const devExtensions = {}
|
|
|
|
|
Array.from(devToolsExtensionNames).forEach(function (name) {
|
2017-07-05 15:34:04 +00:00
|
|
|
if (!extensions[name]) return
|
2017-07-03 18:01:08 +00:00
|
|
|
devExtensions[name] = extensions[name]
|
|
|
|
|
})
|
|
|
|
|
return devExtensions
|
|
|
|
|
}
|
2018-10-19 00:22:42 +00:00
|
|
|
|
|
|
|
|
// Load persisted extensions.
|
|
|
|
|
loadedDevToolsExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')
|
|
|
|
|
try {
|
|
|
|
|
const loadedDevToolsExtensions = JSON.parse(fs.readFileSync(loadedDevToolsExtensionsPath))
|
|
|
|
|
if (Array.isArray(loadedDevToolsExtensions)) {
|
|
|
|
|
for (const srcDirectory of loadedDevToolsExtensions) {
|
|
|
|
|
// Start background pages and set content scripts.
|
|
|
|
|
BrowserWindow.addDevToolsExtension(srcDirectory)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} catch (error) {
|
2018-12-10 20:06:26 +00:00
|
|
|
if (process.env.ELECTRON_ENABLE_LOGGING && error.code !== 'ENOENT') {
|
2018-10-19 00:22:42 +00:00
|
|
|
console.error('Failed to load browser extensions from directory:', loadedDevToolsExtensionsPath)
|
|
|
|
|
console.error(error)
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-03-24 20:15:04 +00:00
|
|
|
})
|
