Cleanup chrome-extension.js after the Coffe2ES transfer

lib/browser/chrome-extension.js

@@ -3,31 +3,34 @@ const fs = require('fs')
 const path = require('path')
 const url = require('url')
 
-// Mapping between hostname and file path.
+// Remove this when we have Object.values().
-var hostPathMap = {}
+const objectValues = function (object) {
-var hostPathMapNextKey = 0
+  return Object.keys(object).map(function (key) { return object[key] })
+}
 
-var generateHostForPath = function (path) {
+// Mapping between hostname and file path.
-  var key
+let hostPathMap = {}
-  key = 'extension-' + (++hostPathMapNextKey)
+let hostPathMapNextKey = 0
+
+const generateHostForPath = function (path) {
+  let key = `extension-${++hostPathMapNextKey}`
   hostPathMap[key] = path
   return key
 }
 
-var getPathForHost = function (host) {
+const getPathForHost = function (host) {
   return hostPathMap[host]
 }
 
 // Cache extensionInfo.
-var extensionInfoMap = {}
+let extensionInfoMap = {}
 
-var getExtensionInfoFromPath = function (srcDirectory) {
+const getExtensionInfoFromPath = function (srcDirectory) {
-  var manifest, page
+  let manifest = JSON.parse(fs.readFileSync(path.join(srcDirectory, 'manifest.json')))
-  manifest = JSON.parse(fs.readFileSync(path.join(srcDirectory, 'manifest.json')))
   if (extensionInfoMap[manifest.name] == null) {
     // We can not use 'file://' directly because all resources in the extension
     // will be treated as relative to the root in Chrome.
-    page = url.format({
+    let page = url.format({
       protocol: 'chrome-extension',
       slashes: true,
       hostname: generateHostForPath(srcDirectory),
@@ -43,13 +46,18 @@ var getExtensionInfoFromPath = function (srcDirectory) {
   }
 }
 
-// The loaded extensions cache and its persistent path.
+// Load the extensions for the window.
-var loadedExtensions = null
+const loadDevToolsExtensions = function (win, extensionInfoArray) {
-var loadedExtensionsPath = null
+  if (!win.devToolsWebContents) return
+  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 {
-    loadedExtensions = Object.keys(extensionInfoMap).map(function (key) {
+    let loadedExtensions = Object.keys(extensionInfoMap).map(function (key) {
       return extensionInfoMap[key].srcDirectory
     })
     if (loadedExtensions.length > 0) {
@@ -69,74 +77,56 @@ app.on('will-quit', function () {
 
 // We can not use protocol or BrowserWindow until app is ready.
 app.once('ready', function () {
-  var chromeExtensionHandler, i, init, len, srcDirectory
-
   // Load persisted extensions.
   loadedExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')
   try {
-    loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath))
+    let loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath))
-    if (!Array.isArray(loadedExtensions)) {
+    if (Array.isArray(loadedExtensions)) {
-      loadedExtensions = []
-    }
-
       // Preheat the extensionInfo cache.
-    for (i = 0, len = loadedExtensions.length; i < len; i++) {
+      for (let srcDirectory of loadedExtensions) {
-      srcDirectory = loadedExtensions[i]
         getExtensionInfoFromPath(srcDirectory)
       }
+    }
   } catch (error) {
     // Ignore error
   }
 
   // The chrome-extension: can map a extension URL request to real file path.
-  chromeExtensionHandler = function (request, callback) {
+  const chromeExtensionHandler = function (request, callback) {
-    var directory, parsed
+    let parsed = url.parse(request.url)
-    parsed = url.parse(request.url)
+    if (!parsed.hostname || !parsed.path) return callback()
-    if (!(parsed.hostname && (parsed.path != null))) {
+    if (!/extension-\d+/.test(parsed.hostname)) return callback()
-      return callback()
+
-    }
+    let directory = getPathForHost(parsed.hostname)
-    if (!/extension-\d+/.test(parsed.hostname)) {
+    if (!directory) return callback()
-      return callback()
+
-    }
+    callback(path.join(directory, parsed.path))
-    directory = getPathForHost(parsed.hostname)
-    if (directory == null) {
-      return callback()
-    }
-    return callback(path.join(directory, parsed.path))
   }
   protocol.registerFileProtocol('chrome-extension', chromeExtensionHandler, function (error) {
     if (error) {
-      return console.error('Unable to register chrome-extension protocol')
+      console.error(`Unable to register chrome-extension protocol: ${error}`)
     }
   })
-  BrowserWindow.prototype._loadDevToolsExtensions = function (extensionInfoArray) {
+
-    var ref
-    return (ref = this.devToolsWebContents) != null ? ref.executeJavaScript('DevToolsAPI.addExtensions(' + (JSON.stringify(extensionInfoArray)) + ');') : void 0
-  }
   BrowserWindow.addDevToolsExtension = function (srcDirectory) {
-    var extensionInfo, j, len1, ref, window
+    let extensionInfo = getExtensionInfoFromPath(srcDirectory)
-    extensionInfo = getExtensionInfoFromPath(srcDirectory)
     if (extensionInfo) {
-      ref = BrowserWindow.getAllWindows()
+      for (let win of BrowserWindow.getAllWindows()) {
-      for (j = 0, len1 = ref.length; j < len1; j++) {
+        loadDevToolsExtensions(win, [extensionInfo])
-        window = ref[j]
-        window._loadDevToolsExtensions([extensionInfo])
       }
       return extensionInfo.name
     }
   }
   BrowserWindow.removeDevToolsExtension = function (name) {
-    return delete extensionInfoMap[name]
+    delete extensionInfoMap[name]
   }
 
   // Load persisted extensions when devtools is opened.
-  init = BrowserWindow.prototype._init
+  let init = BrowserWindow.prototype._init
   BrowserWindow.prototype._init = function () {
     init.call(this)
-    return this.webContents.on('devtools-opened', () => {
+    this.webContents.on('devtools-opened', () => {
-      return this._loadDevToolsExtensions(Object.keys(extensionInfoMap).map(function (key) {
+      loadDevToolsExtensions(this, objectValues(extensionInfoMap))
-        return extensionInfoMap[key]
-      }))
     })
   }
 })