electron/lib/browser/chrome-extension.js

const {app, protocol, webContents, BrowserWindow} = require('electron')
const renderProcessPreferences = process.atomBinding('render_process_preferences').forAllBrowserWindow()

const fs = require('fs')
const path = require('path')
const url = require('url')

// 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 hostname and file path.
const hostPathMap = {}
let hostPathMapNextKey = 0

const generateHostForPath = function (path) {
  const key = `extension-${++hostPathMapNextKey}`
  hostPathMap[key] = path
  return key
}

const getPathForHost = function (host) {
  return hostPathMap[host]
}

// Cache manifests.
const manifestMap = {}

const getManifestFromPath = function (srcDirectory) {
  const manifest = JSON.parse(fs.readFileSync(path.join(srcDirectory, 'manifest.json')))
  if (!manifestMap[manifest.name]) {
    const hostname = generateHostForPath(srcDirectory)
    manifestMap[manifest.name] = manifest
    Object.assign(manifest, {
      srcDirectory: srcDirectory,
      hostname: hostname,
      // 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: hostname,
        pathname: manifest.devtools_page
      })
    })
    return manifest
  }
}

// Manage the background pages.
const backgroundPages = {}

const startBackgroundPages = function (manifest) {
  if (backgroundPages[manifest.hostname] || !manifest.background) return

  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({})
  backgroundPages[manifest.hostname] = { html: html, webContents: contents }
  contents.loadURL(url.format({
    protocol: 'chrome-extension',
    slashes: true,
    hostname: manifest.hostname,
    pathname: '_generated_background_page.html'
  }))
}

const removeBackgroundPages = function (manifest) {
  if (!backgroundPages[manifest.hostname]) return

  backgroundPages[manifest.hostname].webContents.destroy()
  delete backgroundPages[manifest.hostname]
}

// Transfer the content scripts to renderer.
const contentScripts = {}

const injectContentScripts = function (manifest) {
  if (contentScripts[manifest.name] || !manifest.content_scripts) return

  const readArrayOfFiles = function (relativePath) {
    return fs.readFileSync(path.join(manifest.srcDirectory, relativePath))
  }

  const contentScriptToEntry = function (script) {
    return {
      matches: script.matches,
      js: script.js.map(readArrayOfFiles),
      runAt: script.run_at || 'document_idle'
    }
  }

  try {
    const entry = {
      contentScripts: manifest.content_scripts.map(contentScriptToEntry)
    }
    contentScripts[manifest.name] = renderProcessPreferences.addEntry(entry)
  } catch (e) {
    console.error('Failed to read content scripts', e)
  }
}

const removeContentScripts = function (manifest) {
  if (!contentScripts[manifest.name]) return

  renderProcessPreferences.removeEntry(contentScripts[manifest.name])
  delete contentScripts[manifest.name]
}

// 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
  }
}

// Load the extensions for the window.
const loadDevToolsExtensions = function (win, manifests) {
  if (!win.devToolsWebContents) return

  for (const manifest of manifests) {
    startBackgroundPages(manifest)
    injectContentScripts(manifest)
  }
  const extensionInfoArray = manifests.map(manifestToExtensionInfo)
  win.devToolsWebContents.executeJavaScript(`DevToolsAPI.addExtensions(${JSON.stringify(extensionInfoArray)})`)
}

// The persistent path of "DevTools Extensions" preference file.
let loadedExtensionsPath = null

app.on('will-quit', function () {
  try {
    const loadedExtensions = objectValues(manifestMap).map(function (manifest) {
      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)
    }
  } catch (error) {
    // Ignore error
  }
})

// We can not use protocol or BrowserWindow until app is ready.
app.once('ready', function () {
  // Load persisted extensions.
  loadedExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')
  try {
    const loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath))
    if (Array.isArray(loadedExtensions)) {
      // Preheat the manifest cache.
      for (const srcDirectory of loadedExtensions) {
        getManifestFromPath(srcDirectory)
      }
    }
  } catch (error) {
    // Ignore error
  }

  // 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()
    if (!/extension-\d+/.test(parsed.hostname)) return callback()

    const directory = getPathForHost(parsed.hostname)
    if (!directory) return callback()

    if (parsed.path === '/_generated_background_page.html' &&
        backgroundPages[parsed.hostname]) {
      return callback({
        mimeType: 'text/html',
        data: backgroundPages[parsed.hostname].html
      })
    }

    fs.readFile(path.join(directory, parsed.path), function (err, content) {
      if (err) {
        return callback(-6)  // FILE_NOT_FOUND
      } else {
        return callback({mimeType: 'text/html', data: content})
      }
    })
  }
  protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler, function (error) {
    if (error) {
      console.error(`Unable to register chrome-extension protocol: ${error}`)
    }
  })

  BrowserWindow.addDevToolsExtension = function (srcDirectory) {
    const manifest = getManifestFromPath(srcDirectory)
    if (manifest) {
      for (const win of BrowserWindow.getAllWindows()) {
        loadDevToolsExtensions(win, [manifest])
      }
      return manifest.name
    }
  }
  BrowserWindow.removeDevToolsExtension = function (name) {
    const manifest = manifestMap[name]
    if (!manifest) return

    removeBackgroundPages(manifest)
    removeContentScripts(manifest)
    delete manifestMap[name]
  }

  // Load persisted extensions when devtools is opened.
  const init = BrowserWindow.prototype._init
  BrowserWindow.prototype._init = function () {
    init.call(this)
    this.webContents.on('devtools-opened', () => {
      loadDevToolsExtensions(this, objectValues(manifestMap))
    })
  }
})
Add simple support for background page 2016-05-26 09:58:18 +00:00			`const {app, protocol, webContents, BrowserWindow} = require('electron')`
Read content_scripts to preferences 2016-05-27 00:47:37 +00:00			`const renderProcessPreferences = process.atomBinding('render_process_preferences').forAllBrowserWindow()`

first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`const fs = require('fs')`
			`const path = require('path')`
			`const url = require('url')`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Store the original manifest file 2016-05-26 07:57:23 +00:00			`// TODO(zcbenz): Remove this when we have Object.values().`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`const objectValues = function (object) {`
			`return Object.keys(object).map(function (key) { return object[key] })`
			`}`

Use // for single line comments 2016-01-14 18:35:29 +00:00			`// Mapping between hostname and file path.`
The consts 2016-05-26 22:43:23 +00:00			`const hostPathMap = {}`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`let hostPathMapNextKey = 0`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`const generateHostForPath = function (path) {`
The consts 2016-05-26 22:43:23 +00:00			const key = `extension-${++hostPathMapNextKey}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`hostPathMap[key] = path`
			`return key`
			`}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`const getPathForHost = function (host) {`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`return hostPathMap[host]`
			`}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Store the original manifest file 2016-05-26 07:57:23 +00:00			`// Cache manifests.`
The consts 2016-05-26 22:43:23 +00:00			`const manifestMap = {}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Store the original manifest file 2016-05-26 07:57:23 +00:00			`const getManifestFromPath = function (srcDirectory) {`
The consts 2016-05-26 22:43:23 +00:00			`const manifest = JSON.parse(fs.readFileSync(path.join(srcDirectory, 'manifest.json')))`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`if (!manifestMap[manifest.name]) {`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`const hostname = generateHostForPath(srcDirectory)`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`manifestMap[manifest.name] = manifest`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`Object.assign(manifest, {`
			`srcDirectory: srcDirectory,`
			`hostname: hostname,`
			`// 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: hostname,`
			`pathname: manifest.devtools_page`
			`})`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`})`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`return manifest`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Add simple support for background page 2016-05-26 09:58:18 +00:00			`// Manage the background pages.`
The consts 2016-05-26 22:43:23 +00:00			`const backgroundPages = {}`
Add simple support for background page 2016-05-26 09:58:18 +00:00
			`const startBackgroundPages = function (manifest) {`
			`if (backgroundPages[manifest.hostname] \|\| !manifest.background) return`

			`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({})`
Handle unloading devtools correctly 2016-05-27 00:55:59 +00:00			`backgroundPages[manifest.hostname] = { html: html, webContents: contents }`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`contents.loadURL(url.format({`
			`protocol: 'chrome-extension',`
			`slashes: true,`
			`hostname: manifest.hostname,`
			`pathname: '_generated_background_page.html'`
			`}))`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`}`

Handle unloading devtools correctly 2016-05-27 00:55:59 +00:00			`const removeBackgroundPages = function (manifest) {`
			`if (!backgroundPages[manifest.hostname]) return`

			`backgroundPages[manifest.hostname].webContents.destroy()`
			`delete backgroundPages[manifest.hostname]`
			`}`

Read content_scripts to preferences 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) {`
			`return fs.readFileSync(path.join(manifest.srcDirectory, relativePath))`
			`}`

			`const contentScriptToEntry = function (script) {`
			`return {`
			`matches: script.matches,`
			`js: script.js.map(readArrayOfFiles),`
Implement a simple content script injector 2016-05-27 01:29:57 +00:00			`runAt: script.run_at \|\| 'document_idle'`
Read content_scripts to preferences 2016-05-27 00:47:37 +00:00			`}`
			`}`

			`try {`
			`const entry = {`
			`contentScripts: manifest.content_scripts.map(contentScriptToEntry)`
			`}`
			`contentScripts[manifest.name] = renderProcessPreferences.addEntry(entry)`
			`} catch (e) {`
			`console.error('Failed to read content scripts', e)`
			`}`
			`}`

Handle unloading devtools correctly 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]`
			`}`

Store the original manifest file 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`
			`}`
			`}`

Add simple support for background page 2016-05-26 09:58:18 +00:00			`// Load the extensions for the window.`
			`const loadDevToolsExtensions = function (win, manifests) {`
			`if (!win.devToolsWebContents) return`

The consts 2016-05-26 22:43:23 +00:00			`for (const manifest of manifests) {`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`startBackgroundPages(manifest)`
Read content_scripts to preferences 2016-05-27 00:47:37 +00:00			`injectContentScripts(manifest)`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`}`
			`const extensionInfoArray = manifests.map(manifestToExtensionInfo)`
			win.devToolsWebContents.executeJavaScript(`DevToolsAPI.addExtensions(${JSON.stringify(extensionInfoArray)})`)
			`}`

Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`// The persistent path of "DevTools Extensions" preference file.`
			`let loadedExtensionsPath = null`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`app.on('will-quit', function () {`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`try {`
The consts 2016-05-26 22:43:23 +00:00			`const loadedExtensions = objectValues(manifestMap).map(function (manifest) {`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`return manifest.srcDirectory`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`})`
Delete extensions file when there are no loaded extensions 2016-02-04 01:12:09 +00:00			`if (loadedExtensions.length > 0) {`
			`try {`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`fs.mkdirSync(path.dirname(loadedExtensionsPath))`
Delete extensions file when there are no loaded extensions 2016-02-04 01:12:09 +00:00			`} catch (error) {`
			`// Ignore error`
			`}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`fs.writeFileSync(loadedExtensionsPath, JSON.stringify(loadedExtensions))`
Delete extensions file when there are no loaded extensions 2016-02-04 01:12:09 +00:00			`} else {`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`fs.unlinkSync(loadedExtensionsPath)`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
Clean up no-unused-vars lint errors 2016-01-19 22:49:40 +00:00			`} catch (error) {`
			`// Ignore error`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`})`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
Use // for single line comments 2016-01-14 18:35:29 +00:00			`// We can not use protocol or BrowserWindow until app is ready.`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`app.once('ready', function () {`
Correct typo in comment 2016-02-04 00:22:16 +00:00			`// Load persisted extensions.`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`loadedExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`try {`
The consts 2016-05-26 22:43:23 +00:00			`const loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath))`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`if (Array.isArray(loadedExtensions)) {`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`// Preheat the manifest cache.`
The consts 2016-05-26 22:43:23 +00:00			`for (const srcDirectory of loadedExtensions) {`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`getManifestFromPath(srcDirectory)`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
Clean up no-unused-vars lint errors 2016-01-19 22:49:40 +00:00			`} catch (error) {`
			`// Ignore error`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`

Use // for single line comments 2016-01-14 18:35:29 +00:00			`// The chrome-extension: can map a extension URL request to real file path.`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`const chromeExtensionHandler = function (request, callback) {`
The consts 2016-05-26 22:43:23 +00:00			`const parsed = url.parse(request.url)`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`if (!parsed.hostname \|\| !parsed.path) return callback()`
			`if (!/extension-\d+/.test(parsed.hostname)) return callback()`

The consts 2016-05-26 22:43:23 +00:00			`const directory = getPathForHost(parsed.hostname)`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`if (!directory) return callback()`

Add simple support for background page 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(directory, parsed.path), function (err, content) {`
The consts 2016-05-26 22:43:23 +00:00			`if (err) {`
			`return callback(-6) // FILE_NOT_FOUND`
			`} else {`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`return callback({mimeType: 'text/html', data: content})`
The consts 2016-05-26 22:43:23 +00:00			`}`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`})`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`}`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler, function (error) {`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`if (error) {`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			console.error(`Unable to register chrome-extension protocol: ${error}`)
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`})`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`BrowserWindow.addDevToolsExtension = function (srcDirectory) {`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`const manifest = getManifestFromPath(srcDirectory)`
			`if (manifest) {`
The consts 2016-05-26 22:43:23 +00:00			`for (const win of BrowserWindow.getAllWindows()) {`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`loadDevToolsExtensions(win, [manifest])`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`return manifest.name`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00			`}`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`}`
			`BrowserWindow.removeDevToolsExtension = function (name) {`
Handle unloading devtools correctly 2016-05-27 00:55:59 +00:00			`const manifest = manifestMap[name]`
			`if (!manifest) return`

			`removeBackgroundPages(manifest)`
			`removeContentScripts(manifest)`
Store the original manifest file 2016-05-26 07:57:23 +00:00			`delete manifestMap[name]`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`}`
Convert all source files to JavaScript 2016-01-12 02:40:23 +00:00
persistented -> persisted 2016-03-16 16:33:19 +00:00			`// Load persisted extensions when devtools is opened.`
The consts 2016-05-26 22:43:23 +00:00			`const init = BrowserWindow.prototype._init`
standardize by hand 2016-03-29 00:40:40 +00:00			`BrowserWindow.prototype._init = function () {`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`init.call(this)`
Cleanup chrome-extension.js after the Coffe2ES transfer 2016-05-26 07:34:57 +00:00			`this.webContents.on('devtools-opened', () => {`
Add simple support for background page 2016-05-26 09:58:18 +00:00			`loadDevToolsExtensions(this, objectValues(manifestMap))`
first pass at standardizing; suite still passing! 2016-03-24 20:15:04 +00:00			`})`
			`}`
			`})`