electron/lib/browser/chrome-extension.js

353 lines
11 KiB
JavaScript
Raw Normal View History

2016-06-09 05:08:45 +00:00
const {app, ipcMain, session, webContents, BrowserWindow} = require('electron')
2016-06-07 18:02:57 +00:00
const {getAllWebContents} = process.atomBinding('web_contents')
const renderProcessPreferences = process.atomBinding('render_process_preferences').forAllWebContents()
2016-05-27 00:47:37 +00:00
const fs = require('fs')
const path = require('path')
const url = require('url')
2016-01-12 02:40:23 +00:00
2016-05-26 07:57:23 +00:00
// TODO(zcbenz): Remove this when we have Object.values().
const objectValues = function (object) {
return Object.keys(object).map(function (key) { return object[key] })
}
// Mapping between extensionId(hostname) and manifest.
const manifestMap = {} // extensionId => manifest
const manifestNameMap = {} // name => manifest
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
// Create or get manifest object from |srcDirectory|.
2016-05-26 07:57:23 +00:00
const getManifestFromPath = function (srcDirectory) {
let manifest
let manifestContent
try {
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
}
if (!manifestNameMap[manifest.name]) {
2016-05-29 02:57:20 +00:00
const extensionId = generateExtensionIdFromName(manifest.name)
manifestMap[extensionId] = manifestNameMap[manifest.name] = manifest
2016-05-26 09:58:18 +00:00
Object.assign(manifest, {
srcDirectory: srcDirectory,
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,
hostname: extensionId,
2016-05-26 09:58:18 +00:00
pathname: manifest.devtools_page
})
})
2016-05-26 07:57:23 +00:00
return manifest
} 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.`)
2016-01-12 02:40:23 +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) {
if (backgroundPages[manifest.extensionId] || !manifest.background) return
2016-05-26 09:58:18 +00:00
const scripts = manifest.background.scripts.map((name) => {
return `<script src="${name}"></script>`
}).join('')
const html = new Buffer(`<html><body>${scripts}</body></html>`)
const contents = webContents.create({
2016-06-14 16:27:36 +00:00
type: 'backgroundPage',
commandLineSwitches: ['--background-page']
})
backgroundPages[manifest.extensionId] = { html: html, webContents: contents }
2016-05-26 09:58:18 +00:00
contents.loadURL(url.format({
protocol: 'chrome-extension',
slashes: true,
hostname: manifest.extensionId,
2016-05-26 09:58:18 +00:00
pathname: '_generated_background_page.html'
}))
}
2016-05-27 00:55:59 +00:00
const removeBackgroundPages = function (manifest) {
if (!backgroundPages[manifest.extensionId]) return
2016-05-27 00:55:59 +00:00
backgroundPages[manifest.extensionId].webContents.destroy()
delete backgroundPages[manifest.extensionId]
2016-05-27 00:55:59 +00:00
}
// Dispatch tabs events.
const hookWebContentsForTabEvents = function (webContents) {
2016-06-07 16:50:36 +00:00
const tabId = webContents.id
for (const page of objectValues(backgroundPages)) {
page.webContents.sendToAll('CHROME_TABS_ONCREATED', tabId)
}
webContents.once('destroyed', () => {
for (const page of objectValues(backgroundPages)) {
page.webContents.sendToAll('CHROME_TABS_ONREMOVED', tabId)
}
})
}
2016-05-28 01:26:41 +00:00
// Handle the chrome.* API messages.
2016-05-28 03:07:08 +00:00
let nextId = 0
ipcMain.on('CHROME_RUNTIME_CONNECT', function (event, extensionId, connectInfo) {
const page = backgroundPages[extensionId]
2016-05-28 01:26:41 +00:00
if (!page) {
console.error(`Connect to unkown extension ${extensionId}`)
2016-05-28 01:26:41 +00:00
return
}
2016-05-28 03:07:08 +00:00
const portId = ++nextId
event.returnValue = {tabId: page.webContents.id, portId: portId}
2016-05-28 03:07:08 +00:00
event.sender.once('render-view-deleted', () => {
if (page.webContents.isDestroyed()) return
page.webContents.sendToAll(`CHROME_PORT_DISCONNECT_${portId}`)
2016-05-28 03:07:08 +00:00
})
2016-05-28 12:35:07 +00:00
page.webContents.sendToAll(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, event.sender.id, portId, connectInfo)
2016-05-28 03:07:08 +00:00
})
2016-06-07 22:34:17 +00:00
ipcMain.on('CHROME_I18N_MANIFEST', function (event, extensionId) {
event.returnValue = manifestMap[extensionId]
})
2016-05-28 12:23:43 +00:00
ipcMain.on('CHROME_RUNTIME_SENDMESSAGE', function (event, extensionId, message) {
const page = backgroundPages[extensionId]
if (!page) {
console.error(`Connect to unkown extension ${extensionId}`)
return
}
page.webContents.sendToAll(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, event.sender.id, message)
2016-05-28 12:23:43 +00:00
})
ipcMain.on('CHROME_TABS_SEND_MESSAGE', function (event, tabId, extensionId, isBackgroundPage, message) {
const contents = webContents.fromId(tabId)
if (!contents) {
console.error(`Sending message to unkown tab ${tabId}`)
return
}
const senderTabId = isBackgroundPage ? null : event.sender.id
contents.sendToAll(`CHROME_RUNTIME_ONMESSAGE_${extensionId}`, senderTabId, message)
})
ipcMain.on('CHROME_TABS_EXECUTESCRIPT', function (event, requestId, tabId, extensionId, details) {
const contents = webContents.fromId(tabId)
2016-05-28 07:41:12 +00:00
if (!contents) {
console.error(`Sending message to unkown tab ${tabId}`)
2016-05-28 07:41:12 +00:00
return
}
let code, url
if (details.file) {
const manifest = manifestMap[extensionId]
2016-05-28 07:41:12 +00:00
code = String(fs.readFileSync(path.join(manifest.srcDirectory, details.file)))
url = `chrome-extension://${extensionId}${details.file}`
2016-05-28 07:41:12 +00:00
} else {
code = details.code
url = `chrome-extension://${extensionId}/${String(Math.random()).substr(2, 8)}.js`
2016-05-28 07:41:12 +00:00
}
contents.send('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 {
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,
js: script.js.map(readArrayOfFiles),
runAt: script.run_at || 'document_idle'
2016-05-27 00:47:37 +00:00
}
}
try {
const entry = {
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.
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
manifests.forEach(loadExtension)
2016-05-26 09:58:18 +00:00
const extensionInfoArray = manifests.map(manifestToExtensionInfo)
win.devToolsWebContents.executeJavaScript(`DevToolsAPI.addExtensions(${JSON.stringify(extensionInfoArray)})`)
}
2016-06-13 15:59:03 +00:00
app.on('web-contents-created', function (event, webContents) {
if (webContents.getType() === 'remote') return
hookWebContentsForTabEvents(webContents)
webContents.on('devtools-opened', function () {
loadDevToolsExtensions(webContents, objectValues(manifestMap))
})
})
// The persistent path of "DevTools Extensions" preference file.
let loadedExtensionsPath = null
2016-01-12 02:40:23 +00:00
app.on('will-quit', function () {
2016-01-12 02:40:23 +00:00
try {
2016-05-26 22:43:23 +00:00
const loadedExtensions = objectValues(manifestMap).map(function (manifest) {
2016-05-26 07:57:23 +00:00
return manifest.srcDirectory
})
if (loadedExtensions.length > 0) {
try {
fs.mkdirSync(path.dirname(loadedExtensionsPath))
} catch (error) {
// Ignore error
}
fs.writeFileSync(loadedExtensionsPath, JSON.stringify(loadedExtensions))
} else {
fs.unlinkSync(loadedExtensionsPath)
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-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.
app.once('ready', function () {
2016-01-14 18:35:29 +00:00
// The chrome-extension: can map a extension URL request to real file path.
const chromeExtensionHandler = function (request, callback) {
2016-05-26 22:43:23 +00:00
const parsed = url.parse(request.url)
if (!parsed.hostname || !parsed.path) return callback()
const manifest = manifestMap[parsed.hostname]
if (!manifest) return callback()
2016-05-26 09:58:18 +00:00
if (parsed.path === '/_generated_background_page.html' &&
backgroundPages[parsed.hostname]) {
return callback({
mimeType: 'text/html',
data: backgroundPages[parsed.hostname].html
})
}
fs.readFile(path.join(manifest.srcDirectory, parsed.path), function (err, content) {
2016-05-26 22:43:23 +00:00
if (err) {
return callback(-6) // FILE_NOT_FOUND
} else {
2016-05-28 13:36:22 +00:00
return callback(content)
2016-05-26 22:43:23 +00:00
}
2016-05-26 09:58:18 +00:00
})
}
2016-06-09 05:08:45 +00:00
session.on('session-created', function (ses) {
ses.protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler, function (error) {
if (error) {
console.error(`Unable to register chrome-extension protocol: ${error}`)
}
})
})
// Load persisted extensions.
loadedExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')
try {
const loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath))
if (Array.isArray(loadedExtensions)) {
for (const srcDirectory of loadedExtensions) {
// Start background pages and set content scripts.
const manifest = getManifestFromPath(srcDirectory)
loadExtension(manifest)
}
}
} catch (error) {
// Ignore error
}
// The public API to add/remove extensions.
BrowserWindow.addDevToolsExtension = function (srcDirectory) {
2016-05-26 07:57:23 +00:00
const manifest = getManifestFromPath(srcDirectory)
if (manifest) {
2016-06-07 18:02:57 +00:00
for (const webContents of getAllWebContents()) {
if (webContents.getType() !== 'remote') {
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-06-07 16:50:36 +00:00
BrowserWindow.removeDevToolsExtension = function (name) {
const manifest = manifestNameMap[name]
2016-05-27 00:55:59 +00:00
if (!manifest) return
removeBackgroundPages(manifest)
removeContentScripts(manifest)
delete manifestMap[manifest.extensionId]
delete manifestNameMap[name]
}
2016-06-10 16:24:00 +00:00
BrowserWindow.getDevToolsExtensions = function () {
const extensions = {}
Object.keys(manifestNameMap).forEach(function (name) {
const manifest = manifestNameMap[name]
extensions[name] = {name: manifest.name, version: manifest.version}
})
return extensions
}
})