--- a/browser/components/extensions/ext-browser.js
+++ b/browser/components/extensions/ext-browser.js
@@ -3,17 +3,17 @@
 // The ext-* files are imported into the same scopes.
 /* import-globals-from ext-utils.js */
 
 XPCOMUtils.defineLazyModuleGetter(global, "EventEmitter",
                                   "resource://gre/modules/EventEmitter.jsm");
 
 // This function is pretty tightly tied to Extension.jsm.
 // Its job is to fill in the |tab| property of the sender.
-function getSender(extension, target, sender) {
+const getSender = (extension, target, sender) => {
   let tabId;
   if ("tabId" in sender) {
     // The message came from a privileged extension page running in a tab. In
     // that case, it should include a tabId property (which is filled in by the
     // page-open listener below).
     tabId = sender.tabId;
     delete sender.tabId;
   } else if (target instanceof Ci.nsIDOMXULElement) {
@@ -21,17 +21,17 @@ function getSender(extension, target, se
   }
 
   if (tabId) {
     let tab = extension.tabManager.get(tabId, null);
     if (tab) {
       sender.tab = tab.convert();
     }
   }
-}
+};
 
 // Used by Extension.jsm
 global.tabGetSender = getSender;
 
 /* eslint-disable mozilla/balanced-listeners */
 extensions.on("uninstall", (msg, extension) => {
   if (extension.uninstallURL) {
     let browser = windowTracker.topWindow.gBrowser;

--- a/browser/components/extensions/ext-browserAction.js
+++ b/browser/components/extensions/ext-browserAction.js
@@ -38,24 +38,24 @@ var {
 } = ExtensionParent;
 
 const POPUP_PRELOAD_TIMEOUT_MS = 200;
 const POPUP_OPEN_MS_HISTOGRAM = "WEBEXT_BROWSERACTION_POPUP_OPEN_MS";
 const POPUP_RESULT_HISTOGRAM = "WEBEXT_BROWSERACTION_POPUP_PRELOAD_RESULT_COUNT";
 
 var XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
 
-function isAncestorOrSelf(target, node) {
+const isAncestorOrSelf = (target, node) => {
   for (; node; node = node.parentNode) {
     if (node === target) {
       return true;
     }
   }
   return false;
-}
+};
 
 // WeakMap[Extension -> BrowserAction]
 const browserActionMap = new WeakMap();
 
 XPCOMUtils.defineLazyGetter(this, "browserAreas", () => {
   return {
     "navbar": CustomizableUI.AREA_NAVBAR,
     "menupanel": gPhotonStructure ? CustomizableUI.AREA_FIXED_OVERFLOW_PANEL : CustomizableUI.AREA_PANEL,

--- a/browser/components/extensions/ext-browsingData.js
+++ b/browser/components/extensions/ext-browsingData.js
@@ -27,28 +27,28 @@ const YIELD_PERIOD = 10;
 const PREF_DOMAIN = "privacy.cpd.";
 
 XPCOMUtils.defineLazyGetter(this, "sanitizer", () => {
   let sanitizer = new Sanitizer();
   sanitizer.prefDomain = PREF_DOMAIN;
   return sanitizer;
 });
 
-function makeRange(options) {
+const makeRange = options => {
   return (options.since == null) ?
     null :
     [PlacesUtils.toPRTime(options.since), PlacesUtils.toPRTime(Date.now())];
-}
+};
 
-function clearCache() {
+const clearCache = () => {
   // Clearing the cache does not support timestamps.
   return sanitizer.items.cache.clear();
-}
+};
 
-let clearCookies = async function(options) {
+const clearCookies = async function(options) {
   let cookieMgr = Services.cookies;
   // This code has been borrowed from sanitize.js.
   let yieldCounter = 0;
 
   if (options.since) {
     // Iterate through the cookies and delete any created after our cutoff.
     let cookiesEnum = cookieMgr.enumerator;
     while (cookiesEnum.hasMoreElements()) {
@@ -65,29 +65,29 @@ let clearCookies = async function(option
       }
     }
   } else {
     // Remove everything.
     cookieMgr.removeAll();
   }
 };
 
-function clearDownloads(options) {
+const clearDownloads = options => {
   return sanitizer.items.downloads.clear(makeRange(options));
-}
+};
 
-function clearFormData(options) {
+const clearFormData = options => {
   return sanitizer.items.formdata.clear(makeRange(options));
-}
+};
 
-function clearHistory(options) {
+const clearHistory = options => {
   return sanitizer.items.history.clear(makeRange(options));
-}
+};
 
-let clearPasswords = async function(options) {
+const clearPasswords = async function(options) {
   let loginManager = Services.logins;
   let yieldCounter = 0;
 
   if (options.since) {
     // Iterate through the logins and delete any updated after our cutoff.
     let logins = loginManager.getAllLogins();
     for (let login of logins) {
       login.QueryInterface(Ci.nsILoginMetaInfo);
@@ -99,37 +99,37 @@ let clearPasswords = async function(opti
       }
     }
   } else {
     // Remove everything.
     loginManager.removeAllLogins();
   }
 };
 
-function clearPluginData(options) {
+const clearPluginData = options => {
   return sanitizer.items.pluginData.clear(makeRange(options));
-}
+};
 
-let clearServiceWorkers = async function() {
+const clearServiceWorkers = async function() {
   // Clearing service workers does not support timestamps.
   let yieldCounter = 0;
 
   // Iterate through the service workers and remove them.
   let serviceWorkers = serviceWorkerManager.getAllRegistrations();
   for (let i = 0; i < serviceWorkers.length; i++) {
     let sw = serviceWorkers.queryElementAt(i, Ci.nsIServiceWorkerRegistrationInfo);
     let host = sw.principal.URI.host;
     serviceWorkerManager.removeAndPropagate(host);
     if (++yieldCounter % YIELD_PERIOD == 0) {
       await new Promise(resolve => setTimeout(resolve, 0)); // Don't block the main thread too long.
     }
   }
 };
 
-function doRemoval(options, dataToRemove, extension) {
+const doRemoval = (options, dataToRemove, extension) => {
   if (options.originTypes &&
       (options.originTypes.protectedWeb || options.originTypes.extension)) {
     return Promise.reject(
       {message: "Firefox does not support protectedWeb or extension as originTypes."});
   }
 
   let removalPromises = [];
   let invalidDataTypes = [];
@@ -165,17 +165,17 @@ function doRemoval(options, dataToRemove
       }
     }
   }
   if (extension && invalidDataTypes.length) {
     extension.logger.warn(
       `Firefox does not support dataTypes: ${invalidDataTypes.toString()}.`);
   }
   return Promise.all(removalPromises);
-}
+};
 
 this.browsingData = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       browsingData: {
         settings() {
           const PREF_DOMAIN = "privacy.cpd.";

--- a/browser/components/extensions/ext-chrome-settings-overrides.js
+++ b/browser/components/extensions/ext-chrome-settings-overrides.js
@@ -2,32 +2,32 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 XPCOMUtils.defineLazyModuleGetter(this, "ExtensionPreferencesManager",
                                   "resource://gre/modules/ExtensionPreferencesManager.jsm");
 
-function searchInitialized() {
+const searchInitialized = () => {
   return new Promise(resolve => {
     if (Services.search.isInitialized) {
       resolve();
     }
     const SEARCH_SERVICE_TOPIC = "browser-search-service";
     Services.obs.addObserver(function observer(subject, topic, data) {
       if (data != "init-complete") {
         return;
       }
 
       Services.obs.removeObserver(observer, SEARCH_SERVICE_TOPIC);
       resolve();
     }, SEARCH_SERVICE_TOPIC);
   });
-}
+};
 
 this.chrome_settings_overrides = class extends ExtensionAPI {
   async onManifestEntry(entryName) {
     let {extension} = this;
     let {manifest} = extension;
 
     if (manifest.chrome_settings_overrides.homepage) {
       ExtensionPreferencesManager.setSetting(extension, "homepage_override",

--- a/browser/components/extensions/ext-geckoProfiler.js
+++ b/browser/components/extensions/ext-geckoProfiler.js
@@ -17,30 +17,30 @@ const PREF_SYMBOLS_URL = "extensions.gec
 const PREF_GET_SYMBOL_RULES = "extensions.geckoProfiler.getSymbolRules";
 
 const ASYNC_STACKS_ENABLED = Services.prefs.getBoolPref(PREF_ASYNC_STACK, false);
 
 var {
   ExtensionError,
 } = ExtensionUtils;
 
-function parseSym(data) {
+const parseSym = data => {
   const worker = new ChromeWorker("resource://app/modules/ParseSymbols-worker.js");
   const promise = new Promise((resolve, reject) => {
     worker.onmessage = (e) => {
       if (e.data.error) {
         reject(e.data.error);
       } else {
         resolve(e.data.result);
       }
     };
   });
   worker.postMessage(data);
   return promise;
-}
+};
 
 class NMParser {
   constructor() {
     this._addrToSymMap = new Map();
     this._approximateLength = 0;
   }
 
   consume(data) {
@@ -115,40 +115,40 @@ class CppFiltParser {
     return this._results;
   }
 
   _processLine(line) {
     this._results[this._index++] = line.trimRight();
   }
 }
 
-async function readAllData(pipe, processData) {
+const readAllData = async function(pipe, processData) {
   let data;
   while ((data = await pipe.readString())) {
     processData(data);
   }
-}
+};
 
-async function spawnProcess(name, cmdArgs, processData, stdin = null) {
+const spawnProcess = async function(name, cmdArgs, processData, stdin = null) {
   const opts = {
     command: await Subprocess.pathSearch(name),
     arguments: cmdArgs,
   };
   const proc = await Subprocess.call(opts);
 
   if (stdin) {
     const encoder = new TextEncoder("utf-8");
     proc.stdin.write(encoder.encode(stdin));
     proc.stdin.close();
   }
 
   await readAllData(proc.stdout, processData);
-}
+};
 
-async function getSymbolsFromNM(path, arch) {
+const getSymbolsFromNM = async function(path, arch) {
   const parser = new NMParser();
 
   const args = [path];
   if (Services.appinfo.OS === "Darwin") {
     args.unshift("-arch", arch);
   } else {
     // Mac's `nm` doesn't support the demangle option, so we have to
     // post-process the symbols with c++filt.
@@ -168,65 +168,65 @@ async function getSymbolsFromNM(path, ar
     approximateLength = 0;
     for (let [i, symbol] of newSymbols.entries()) {
       approximateLength += symbol.length;
       syms.set(keys[i], symbol);
     }
   }
 
   return ParseSymbols.convertSymsMapToExpectedSymFormat(syms, approximateLength);
-}
+};
 
-function pathComponentsForSymbolFile(debugName, breakpadId) {
+const pathComponentsForSymbolFile = (debugName, breakpadId) => {
   const symName = debugName.replace(/(\.pdb)?$/, ".sym");
   return [debugName, breakpadId, symName];
-}
+};
 
-function urlForSymFile(debugName, breakpadId) {
+const urlForSymFile = (debugName, breakpadId) => {
   const profilerSymbolsURL = Services.prefs.getCharPref(PREF_SYMBOLS_URL,
                                                         "http://symbols.mozilla.org/");
   return profilerSymbolsURL + pathComponentsForSymbolFile(debugName, breakpadId).join("/");
-}
+};
 
-function getContainingObjdirDist(path) {
+const getContainingObjdirDist = path => {
   let curPath = path;
   let curPathBasename = OS.Path.basename(curPath);
   while (curPathBasename) {
     if (curPathBasename === "dist") {
       return curPath;
     }
     const parentDirPath = OS.Path.dirname(curPath);
     if (curPathBasename === "bin") {
       return parentDirPath;
     }
     curPath = parentDirPath;
     curPathBasename = OS.Path.basename(curPath);
   }
   return null;
-}
+};
 
-function filePathForSymFileInObjDir(binaryPath, debugName, breakpadId) {
+const filePathForSymFileInObjDir = (binaryPath, debugName, breakpadId) => {
   // `mach buildsymbols` generates symbol files located
   // at /path/to/objdir/dist/crashreporter-symbols/.
   const objDirDist = getContainingObjdirDist(binaryPath);
   if (!objDirDist) {
     return null;
   }
   return OS.Path.join(objDirDist,
                       "crashreporter-symbols",
                       ...pathComponentsForSymbolFile(debugName, breakpadId));
-}
+};
 
 const symbolCache = new Map();
 
-function primeSymbolStore(libs) {
+const primeSymbolStore = libs => {
   for (const {debugName, breakpadId, path, arch} of libs) {
     symbolCache.set(urlForSymFile(debugName, breakpadId), {path, arch});
   }
-}
+};
 
 const isRunningObserver = {
   _observers: new Set(),
 
   observe(subject, topic, data) {
     switch (topic) {
       case "profiler-started":
       case "profiler-stopped":

--- a/browser/components/extensions/ext-history.js
+++ b/browser/components/extensions/ext-history.js
@@ -23,79 +23,79 @@ const TRANSITION_TO_TRANSITION_TYPES_MAP
   ["manual_subframe", nsINavHistoryService.TRANSITION_FRAMED_LINK],
 ]);
 
 let TRANSITION_TYPE_TO_TRANSITIONS_MAP = new Map();
 for (let [transition, transitionType] of TRANSITION_TO_TRANSITION_TYPES_MAP) {
   TRANSITION_TYPE_TO_TRANSITIONS_MAP.set(transitionType, transition);
 }
 
-function getTransitionType(transition) {
+const getTransitionType = transition => {
   // cannot set a default value for the transition argument as the framework sets it to null
   transition = transition || "link";
   let transitionType = TRANSITION_TO_TRANSITION_TYPES_MAP.get(transition);
   if (!transitionType) {
     throw new Error(`|${transition}| is not a supported transition for history`);
   }
   return transitionType;
-}
+};
 
-function getTransition(transitionType) {
+const getTransition = transitionType => {
   return TRANSITION_TYPE_TO_TRANSITIONS_MAP.get(transitionType) || "link";
-}
+};
 
 /*
  * Converts a nsINavHistoryResultNode into a HistoryItem
  *
  * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryResultNode
  */
-function convertNodeToHistoryItem(node) {
+const convertNodeToHistoryItem = node => {
   return {
     id: node.pageGuid,
     url: node.uri,
     title: node.title,
     lastVisitTime: PlacesUtils.toDate(node.time).getTime(),
     visitCount: node.accessCount,
   };
-}
+};
 
 /*
  * Converts a nsINavHistoryResultNode into a VisitItem
  *
  * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryResultNode
  */
-function convertNodeToVisitItem(node) {
+const convertNodeToVisitItem = node => {
   return {
     id: node.pageGuid,
     visitId: node.visitId,
     visitTime: PlacesUtils.toDate(node.time).getTime(),
     referringVisitId: node.fromVisitId,
     transition: getTransition(node.visitType),
   };
-}
+};
 
 /*
  * Converts a nsINavHistoryContainerResultNode into an array of objects
  *
  * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryContainerResultNode
  */
-function convertNavHistoryContainerResultNode(container, converter) {
+const convertNavHistoryContainerResultNode = (container, converter) => {
   let results = [];
   container.containerOpen = true;
   for (let i = 0; i < container.childCount; i++) {
     let node = container.getChild(i);
     results.push(converter(node));
   }
   container.containerOpen = false;
   return results;
-}
+};
 
 var _observer;
 
-function getObserver() {
+const getHistoryObserver = () => {
   if (!_observer) {
     _observer = {
       onDeleteURI: function(uri, guid, reason) {
         this.emit("visitRemoved", {allHistory: false, urls: [uri.spec]});
       },
       onVisit: function(uri, visitId, time, sessionId, referringId, transitionType, guid, hidden, visitCount, typed) {
         let data = {
           id: guid,
@@ -121,17 +121,17 @@ function getObserver() {
       onDeleteVisits: function(uri, time, guid, reason) {
         this.emit("visitRemoved", {allHistory: false, urls: [uri.spec]});
       },
     };
     EventEmitter.decorate(_observer);
     PlacesUtils.history.addObserver(_observer);
   }
   return _observer;
-}
+};
 
 this.history = class extends ExtensionAPI {
   getAPI(context) {
     return {
       history: {
         addUrl: function(details) {
           let transition, date;
           try {
@@ -219,39 +219,39 @@ this.history = class extends ExtensionAP
           return Promise.resolve(results);
         },
 
         onVisited: new SingletonEventManager(context, "history.onVisited", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
-          getObserver().on("visited", listener);
+          getHistoryObserver().on("visited", listener);
           return () => {
-            getObserver().off("visited", listener);
+            getHistoryObserver().off("visited", listener);
           };
         }).api(),
 
         onVisitRemoved: new SingletonEventManager(context, "history.onVisitRemoved", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
-          getObserver().on("visitRemoved", listener);
+          getHistoryObserver().on("visitRemoved", listener);
           return () => {
-            getObserver().off("visitRemoved", listener);
+            getHistoryObserver().off("visitRemoved", listener);
           };
         }).api(),
 
         onTitleChanged: new SingletonEventManager(context, "history.onTitleChanged", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
-          getObserver().on("titleChanged", listener);
+          getHistoryObserver().on("titleChanged", listener);
           return () => {
-            getObserver().off("titleChanged", listener);
+            getHistoryObserver().off("titleChanged", listener);
           };
         }).api(),
       },
     };
   }
 };

--- a/browser/components/extensions/ext-menus.js
+++ b/browser/components/extensions/ext-menus.js
@@ -293,17 +293,17 @@ var gMenuBuilder = {
   itemsToCleanUp: new Set(),
 };
 
 // Called from pageAction or browserAction popup.
 global.actionContextMenu = function(contextData) {
   gMenuBuilder.buildActionContextMenu(contextData);
 };
 
-function getContexts(contextData) {
+const getMenuContexts = contextData => {
   let contexts = new Set();
 
   if (contextData.inFrame) {
     contexts.add("frame");
   }
 
   if (contextData.isTextSelected) {
     contexts.add("selection");
@@ -350,17 +350,17 @@ function getContexts(contextData) {
   }
 
   // New non-content contexts supported in Firefox are not part of "all".
   if (!contextData.onTab) {
     contexts.add("all");
   }
 
   return contexts;
-}
+};
 
 function MenuItem(extension, createProperties, isRoot = false) {
   this.extension = extension;
   this.children = [];
   this.parent = null;
   this.tabManager = extension.tabManager;
 
   this.setDefaults();
@@ -540,17 +540,17 @@ MenuItem.prototype = {
       info.checked = this.checked;
       info.wasChecked = wasChecked;
     }
 
     return info;
   },
 
   enabledForContext(contextData) {
-    let contexts = getContexts(contextData);
+    let contexts = getMenuContexts(contextData);
     if (!this.contexts.some(n => contexts.has(n))) {
       return false;
     }
 
     let docPattern = this.documentUrlMatchPattern;
     let pageURI = Services.io.newURI(contextData[contextData.inFrame ? "frameUrl" : "pageUrl"]);
     if (docPattern && !docPattern.matches(pageURI)) {
       return false;

--- a/browser/components/extensions/ext-sessions.js
+++ b/browser/components/extensions/ext-sessions.js
@@ -10,17 +10,17 @@ var {
   promiseObserved,
 } = ExtensionUtils;
 
 XPCOMUtils.defineLazyModuleGetter(this, "SessionStore",
                                   "resource:///modules/sessionstore/SessionStore.jsm");
 
 const SS_ON_CLOSED_OBJECTS_CHANGED = "sessionstore-closed-objects-changed";
 
-function getRecentlyClosed(maxResults, extension) {
+const getRecentlyClosed = (maxResults, extension) => {
   let recentlyClosed = [];
 
   // Get closed windows
   let closedWindowData = SessionStore.getClosedWindowData(false);
   for (let window of closedWindowData) {
     recentlyClosed.push({
       lastModified: window.closedAt,
       window: Window.convertFromSessionStoreClosedData(extension, window)});
@@ -34,31 +34,31 @@ function getRecentlyClosed(maxResults, e
         lastModified: tab.closedAt,
         tab: Tab.convertFromSessionStoreClosedData(extension, tab, window)});
     }
   }
 
   // Sort windows and tabs
   recentlyClosed.sort((a, b) => b.lastModified - a.lastModified);
   return recentlyClosed.slice(0, maxResults);
-}
+};
 
-async function createSession(restored, extension, sessionId) {
+const createSession = async function createSession(restored, extension, sessionId) {
   if (!restored) {
     throw new ExtensionError(`Could not restore object using sessionId ${sessionId}.`);
   }
   let sessionObj = {lastModified: Date.now()};
   if (restored instanceof Ci.nsIDOMChromeWindow) {
     await promiseObserved("sessionstore-single-window-restored", subject => subject == restored);
     sessionObj.window = extension.windowManager.convert(restored, {populate: true});
     return sessionObj;
   }
   sessionObj.tab = extension.tabManager.convert(restored);
   return sessionObj;
-}
+};
 
 this.sessions = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       sessions: {
         async getRecentlyClosed(filter) {
           await SessionStore.promiseInitialized;

--- a/browser/components/extensions/ext-windows.js
+++ b/browser/components/extensions/ext-windows.js
@@ -12,19 +12,19 @@ XPCOMUtils.defineLazyModuleGetter(this, 
                                   "resource://gre/modules/AppConstants.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",
                                   "resource://gre/modules/PrivateBrowsingUtils.jsm");
 
 var {
   promiseObserved,
 } = ExtensionUtils;
 
-function onXULFrameLoaderCreated({target}) {
+const onXULFrameLoaderCreated = ({target}) => {
   target.messageManager.sendAsyncMessage("AllowScriptsToClose", {});
-}
+};
 
 this.windows = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
 
     const {windowManager} = extension;
 
     return {