--- a/toolkit/components/extensions/ext-browserSettings.js
+++ b/toolkit/components/extensions/ext-browserSettings.js
@@ -2,17 +2,17 @@
 /* vim: set sts=2 sw=2 et tw=80: */
 "use strict";
 
 XPCOMUtils.defineLazyModuleGetter(this, "Preferences",
                                   "resource://gre/modules/Preferences.jsm");
 
 Cu.import("resource://gre/modules/ExtensionPreferencesManager.jsm");
 
-function getAPI(extension, name, callback) {
+const getSettingsAPI = (extension, name, callback) => {
   return {
     async get(details) {
       return {
         levelOfControl: details.incognito ?
           "not_controllable" :
           await ExtensionPreferencesManager.getLevelOfControl(
             extension, name),
         value: await callback(),
@@ -21,17 +21,17 @@ function getAPI(extension, name, callbac
     set(details) {
       return ExtensionPreferencesManager.setSetting(
         extension, name, details.value);
     },
     clear(details) {
       return ExtensionPreferencesManager.removeSetting(extension, name);
     },
   };
-}
+};
 
 // Add settings objects for supported APIs to the preferences manager.
 ExtensionPreferencesManager.addSetting("cacheEnabled", {
   prefNames: [
     "browser.cache.disk.enable",
     "browser.cache.memory.enable",
   ],
 
@@ -44,17 +44,17 @@ ExtensionPreferencesManager.addSetting("
   },
 });
 
 this.browserSettings = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       browserSettings: {
-        cacheEnabled: getAPI(extension,
+        cacheEnabled: getSettingsAPI(extension,
           "cacheEnabled",
           () => {
             return Preferences.get("browser.cache.disk.enable") &&
               Preferences.get("browser.cache.memory.enable");
           }),
       },
     };
   }

--- a/toolkit/components/extensions/ext-c-identity.js
+++ b/toolkit/components/extensions/ext-c-identity.js
@@ -14,24 +14,24 @@ XPCOMUtils.defineLazyPreferenceGetter(th
 let CryptoHash = CC("@mozilla.org/security/hash;1", "nsICryptoHash", "initWithString");
 
 Cu.importGlobalProperties(["URL", "XMLHttpRequest", "TextEncoder"]);
 
 var {
   promiseDocumentLoaded,
 } = ExtensionUtils;
 
-function computeHash(str) {
+const computeHash = str => {
   let byteArr = new TextEncoder().encode(str);
   let hash = new CryptoHash("sha1");
   hash.update(byteArr, byteArr.length);
   return CommonUtils.bytesAsHex(hash.finish(false));
-}
+};
 
-function checkRedirected(url, redirectURI) {
+const checkRedirected = (url, redirectURI) => {
   return new Promise((resolve, reject) => {
     let xhr = new XMLHttpRequest();
     xhr.open("HEAD", url);
     // We expect this if the user has not authenticated.
     xhr.onload = () => {
       reject(0);
     };
     // An unexpected error happened, log for extension authors.
@@ -52,19 +52,19 @@ function checkRedirected(url, redirectUR
           callback.onRedirectVerifyCallback(Components.results.NS_BINDING_ABORTED);
           return;
         }
         callback.onRedirectVerifyCallback(Components.results.NS_OK);
       },
     };
     xhr.send();
   });
-}
+};
 
-function openOAuthWindow(details, redirectURI) {
+const openOAuthWindow = (details, redirectURI) => {
   let args = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
   let supportsStringPrefURL = Cc["@mozilla.org/supports-string;1"]
                                 .createInstance(Ci.nsISupportsString);
   supportsStringPrefURL.data = details.url;
   args.appendElement(supportsStringPrefURL);
 
   let window = Services.ww.openWindow(null,
                                       Services.prefs.getCharPref("browser.chromeURL"),
@@ -96,17 +96,17 @@ function openOAuthWindow(details, redire
       onSecurityChange() {},
     };
 
     promiseDocumentLoaded(window.document).then(() => {
       window.gBrowser.addTabsProgressListener(wpl);
       window.addEventListener("unload", unloadlistener);
     });
   });
-}
+};
 
 this.identity = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       identity: {
         launchWebAuthFlow: function(details) {
           // In OAuth2 the url should have a redirect_uri param, parse the url and grab it

--- a/toolkit/components/extensions/ext-c-test.js
+++ b/toolkit/components/extensions/ext-c-test.js
@@ -16,17 +16,17 @@
  *        - a function, it is called with the error object and its
  *          return value is returned.
  *        - null, the function always returns true.
  * @param {BaseContext} context
  *
  * @returns {boolean}
  *        True if the error matches the expected error.
  */
-function errorMatches(error, expectedError, context) {
+const errorMatches = (error, expectedError, context) => {
   if (expectedError === null) {
     return true;
   }
 
   if (typeof expectedError === "function") {
     return context.runSafeWithoutClone(expectedError, error);
   }
 
@@ -41,42 +41,42 @@ function errorMatches(error, expectedErr
 
   try {
     return expectedError.test(error.message);
   } catch (e) {
     Cu.reportError(e);
   }
 
   return false;
-}
+};
 
 /**
  * Calls .toSource() on the given value, but handles null, undefined,
  * and errors.
  *
  * @param {*} value
  * @returns {string}
  */
-function toSource(value) {
+const toSource = value => {
   if (value === null) {
     return "null";
   }
   if (value === undefined) {
     return "undefined";
   }
   if (typeof value === "string") {
     return JSON.stringify(value);
   }
 
   try {
     return String(value.toSource());
   } catch (e) {
     return "<unknown>";
   }
-}
+};
 
 this.test = class extends ExtensionAPI {
   getAPI(context) {
     const {extension} = context;
 
     function getStack() {
       return new context.cloneScope.Error().stack.replace(/^/gm, "    ");
     }

--- a/toolkit/components/extensions/ext-contextualIdentities.js
+++ b/toolkit/components/extensions/ext-contextualIdentities.js
@@ -3,72 +3,72 @@
 // The ext-* files are imported into the same scopes.
 /* import-globals-from ext-toolkit.js */
 
 XPCOMUtils.defineLazyModuleGetter(this, "ContextualIdentityService",
                                   "resource://gre/modules/ContextualIdentityService.jsm");
 XPCOMUtils.defineLazyPreferenceGetter(this, "containersEnabled",
                                       "privacy.userContext.enabled");
 
-function convert(identity) {
+const convertIdentity = identity => {
   let result = {
     name: ContextualIdentityService.getUserContextLabel(identity.userContextId),
     icon: identity.icon,
     color: identity.color,
     cookieStoreId: getCookieStoreIdForContainer(identity.userContextId),
   };
 
   return result;
-}
+};
 
 this.contextualIdentities = class extends ExtensionAPI {
   getAPI(context) {
     let self = {
       contextualIdentities: {
         get(cookieStoreId) {
           if (!containersEnabled) {
             return Promise.resolve(false);
           }
 
           let containerId = getContainerForCookieStoreId(cookieStoreId);
           if (!containerId) {
             return Promise.resolve(null);
           }
 
           let identity = ContextualIdentityService.getPublicIdentityFromId(containerId);
-          return Promise.resolve(convert(identity));
+          return Promise.resolve(convertIdentity(identity));
         },
 
         query(details) {
           if (!containersEnabled) {
             return Promise.resolve(false);
           }
 
           let identities = [];
           ContextualIdentityService.getPublicIdentities().forEach(identity => {
             if (details.name &&
                 ContextualIdentityService.getUserContextLabel(identity.userContextId) != details.name) {
               return;
             }
 
-            identities.push(convert(identity));
+            identities.push(convertIdentity(identity));
           });
 
           return Promise.resolve(identities);
         },
 
         create(details) {
           if (!containersEnabled) {
             return Promise.resolve(false);
           }
 
           let identity = ContextualIdentityService.create(details.name,
                                                           details.icon,
                                                           details.color);
-          return Promise.resolve(convert(identity));
+          return Promise.resolve(convertIdentity(identity));
         },
 
         update(cookieStoreId, details) {
           if (!containersEnabled) {
             return Promise.resolve(false);
           }
 
           let containerId = getContainerForCookieStoreId(cookieStoreId);
@@ -94,17 +94,17 @@ this.contextualIdentities = class extend
           }
 
           if (!ContextualIdentityService.update(identity.userContextId,
                                                 identity.name, identity.icon,
                                                 identity.color)) {
             return Promise.resolve(null);
           }
 
-          return Promise.resolve(convert(identity));
+          return Promise.resolve(convertIdentity(identity));
         },
 
         remove(cookieStoreId) {
           if (!containersEnabled) {
             return Promise.resolve(false);
           }
 
           let containerId = getContainerForCookieStoreId(cookieStoreId);
@@ -113,17 +113,17 @@ this.contextualIdentities = class extend
           }
 
           let identity = ContextualIdentityService.getPublicIdentityFromId(containerId);
           if (!identity) {
             return Promise.resolve(null);
           }
 
           // We have to create the identity object before removing it.
-          let convertedIdentity = convert(identity);
+          let convertedIdentity = convertIdentity(identity);
 
           if (!ContextualIdentityService.remove(identity.userContextId)) {
             return Promise.resolve(null);
           }
 
           return Promise.resolve(convertedIdentity);
         },
       },

--- a/toolkit/components/extensions/ext-downloads.js
+++ b/toolkit/components/extensions/ext-downloads.js
@@ -230,17 +230,17 @@ const DownloadMap = {
     return this.getDownloadList().then(list => {
       list.remove(item.download);
     });
   },
 };
 
 // Create a callable function that filters a DownloadItem based on a
 // query object of the type passed to search() or erase().
-function downloadQuery(query) {
+const downloadQuery = query => {
   let queryTerms = [];
   let queryNegativeTerms = [];
   if (query.query != null) {
     for (let term of query.query) {
       if (term[0] == "-") {
         queryNegativeTerms.push(term.slice(1).toLowerCase());
       } else {
         queryTerms.push(term.toLowerCase());
@@ -332,19 +332,19 @@ function downloadQuery(query) {
     for (let field of SIMPLE_ITEMS) {
       if (query[field] != null && item[field] != query[field]) {
         return false;
       }
     }
 
     return true;
   };
-}
+};
 
-function queryHelper(query) {
+const queryHelper = query => {
   let matchFn;
   try {
     matchFn = downloadQuery(query);
   } catch (err) {
     return Promise.reject({message: err.message});
   }
 
   let compareFn;
@@ -385,17 +385,17 @@ function queryHelper(query) {
         break;
       }
       if (matchFn(download)) {
         results.push(download);
       }
     }
     return results;
   });
-}
+};
 
 this.downloads = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       downloads: {
         download(options) {
           let {filename} = options;

--- a/toolkit/components/extensions/ext-idle.js
+++ b/toolkit/components/extensions/ext-idle.js
@@ -7,17 +7,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
                                   "resource://gre/modules/EventEmitter.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "idleService",
                                    "@mozilla.org/widget/idleservice;1",
                                    "nsIIdleService");
 
 // WeakMap[Extension -> Object]
 let observersMap = new WeakMap();
 
-function getObserverInfo(extension, context) {
+const getIdleObserverInfo = (extension, context) => {
   let observerInfo = observersMap.get(extension);
   if (!observerInfo) {
     observerInfo = {
       observer: null,
       detectionInterval: 60,
     };
     observersMap.set(extension, observerInfo);
     context.callOnClose({
@@ -26,46 +26,46 @@ function getObserverInfo(extension, cont
         if (observer) {
           idleService.removeIdleObserver(observer, detectionInterval);
         }
         observersMap.delete(extension);
       },
     });
   }
   return observerInfo;
-}
+};
 
-function getObserver(extension, context) {
-  let observerInfo = getObserverInfo(extension, context);
+const getIdleObserver = (extension, context) => {
+  let observerInfo = getIdleObserverInfo(extension, context);
   let {observer, detectionInterval} = observerInfo;
   if (!observer) {
     observer = {
       observe: function(subject, topic, data) {
         if (topic == "idle" || topic == "active") {
           this.emit("stateChanged", topic);
         }
       },
     };
     EventEmitter.decorate(observer);
     idleService.addIdleObserver(observer, detectionInterval);
     observerInfo.observer = observer;
     observerInfo.detectionInterval = detectionInterval;
   }
   return observer;
-}
+};
 
-function setDetectionInterval(extension, context, newInterval) {
-  let observerInfo = getObserverInfo(extension, context);
+const setDetectionInterval = (extension, context, newInterval) => {
+  let observerInfo = getIdleObserverInfo(extension, context);
   let {observer, detectionInterval} = observerInfo;
   if (observer) {
     idleService.removeIdleObserver(observer, detectionInterval);
     idleService.addIdleObserver(observer, newInterval);
   }
   observerInfo.detectionInterval = newInterval;
-}
+};
 
 this.idle = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       idle: {
         queryState: function(detectionIntervalInSeconds) {
           if (idleService.idleTime < detectionIntervalInSeconds * 1000) {
@@ -76,17 +76,17 @@ this.idle = class extends ExtensionAPI {
         setDetectionInterval: function(detectionIntervalInSeconds) {
           setDetectionInterval(extension, context, detectionIntervalInSeconds);
         },
         onStateChanged: new SingletonEventManager(context, "idle.onStateChanged", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
-          getObserver(extension, context).on("stateChanged", listener);
+          getIdleObserver(extension, context).on("stateChanged", listener);
           return () => {
-            getObserver(extension, context).off("stateChanged", listener);
+            getIdleObserver(extension, context).off("stateChanged", listener);
           };
         }).api(),
       },
     };
   }
 };

--- a/toolkit/components/extensions/ext-management.js
+++ b/toolkit/components/extensions/ext-management.js
@@ -21,35 +21,35 @@ XPCOMUtils.defineLazyGetter(this, "Globa
   const {GlobalManager} = Cu.import("resource://gre/modules/Extension.jsm", {});
   return GlobalManager;
 });
 
 var {
   ExtensionError,
 } = ExtensionUtils;
 
-function _(key, ...args) {
+const _ = (key, ...args) => {
   if (args.length) {
     return strBundle.formatStringFromName(key, args, args.length);
   }
   return strBundle.GetStringFromName(key);
-}
+};
 
-function installType(addon) {
+const installType = addon => {
   if (addon.temporarilyInstalled) {
     return "development";
   } else if (addon.foreignInstall) {
     return "sideload";
   } else if (addon.isSystem) {
     return "other";
   }
   return "normal";
-}
+};
 
-function getExtensionInfoForAddon(extension, addon) {
+const getExtensionInfoForAddon = (extension, addon) => {
   let extInfo = {
     id: addon.id,
     name: addon.name,
     description: addon.description || "",
     version: addon.version,
     mayDisable: !!(addon.permissions & AddonManager.PERM_CAN_DISABLE),
     enabled: addon.isActive,
     optionsUrl: addon.optionsURL || "",
@@ -80,17 +80,17 @@ function getExtensionInfoForAddon(extens
   }
   if (addon.homepageURL) {
     extInfo.homepageUrl = addon.homepageURL;
   }
   if (addon.updateURL) {
     extInfo.updateUrl = addon.updateURL;
   }
   return extInfo;
-}
+};
 
 const listenerMap = new WeakMap();
 // Some management APIs are intentionally limited.
 const allowedTypes = ["theme", "extension"];
 
 class AddonListener {
   constructor() {
     AddonManager.addAddonListener(this);
@@ -136,34 +136,34 @@ class AddonListener {
       return;
     }
     this.emit("onUninstalled", this.getExtensionInfo(addon));
   }
 }
 
 let addonListener;
 
-function getListener(extension, context) {
+const getManagementListener = (extension, context) => {
   if (!listenerMap.has(extension)) {
     if (!addonListener) {
       addonListener = new AddonListener();
     }
     listenerMap.set(extension, {});
     context.callOnClose({
       close: () => {
         listenerMap.delete(extension);
         if (listenerMap.length === 0) {
           addonListener.release();
           addonListener = null;
         }
       },
     });
   }
   return addonListener;
-}
+};
 
 this.management = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       management: {
         async get(id) {
           let addon = await AddonManager.getAddonByID(id);
@@ -224,51 +224,51 @@ this.management = class extends Extensio
           addon.userDisabled = !enabled;
         },
 
         onDisabled: new SingletonEventManager(context, "management.onDisabled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
-          getListener(extension, context).on("onDisabled", listener);
+          getManagementListener(extension, context).on("onDisabled", listener);
           return () => {
-            getListener(extension, context).off("onDisabled", listener);
+            getManagementListener(extension, context).off("onDisabled", listener);
           };
         }).api(),
 
         onEnabled: new SingletonEventManager(context, "management.onEnabled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
-          getListener(extension, context).on("onEnabled", listener);
+          getManagementListener(extension, context).on("onEnabled", listener);
           return () => {
-            getListener(extension, context).off("onEnabled", listener);
+            getManagementListener(extension, context).off("onEnabled", listener);
           };
         }).api(),
 
         onInstalled: new SingletonEventManager(context, "management.onInstalled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
-          getListener(extension, context).on("onInstalled", listener);
+          getManagementListener(extension, context).on("onInstalled", listener);
           return () => {
-            getListener(extension, context).off("onInstalled", listener);
+            getManagementListener(extension, context).off("onInstalled", listener);
           };
         }).api(),
 
         onUninstalled: new SingletonEventManager(context, "management.onUninstalled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
-          getListener(extension, context).on("onUninstalled", listener);
+          getManagementListener(extension, context).on("onUninstalled", listener);
           return () => {
-            getListener(extension, context).off("onUninstalled", listener);
+            getManagementListener(extension, context).off("onUninstalled", listener);
           };
         }).api(),
 
       },
     };
   }
 };

--- a/toolkit/components/extensions/ext-privacy.js
+++ b/toolkit/components/extensions/ext-privacy.js
@@ -5,24 +5,24 @@
 XPCOMUtils.defineLazyModuleGetter(this, "Preferences",
                                   "resource://gre/modules/Preferences.jsm");
 
 Cu.import("resource://gre/modules/ExtensionPreferencesManager.jsm");
 var {
   ExtensionError,
 } = ExtensionUtils;
 
-function checkScope(scope) {
+const checkScope = scope => {
   if (scope && scope !== "regular") {
     throw new ExtensionError(
       `Firefox does not support the ${scope} settings scope.`);
   }
-}
+};
 
-function getAPI(extension, name, callback) {
+const getPrivacyAPI = (extension, name, callback) => {
   return {
     async get(details) {
       return {
         levelOfControl: details.incognito ?
           "not_controllable" :
           await ExtensionPreferencesManager.getLevelOfControl(
             extension, name),
         value: await callback(),
@@ -34,17 +34,17 @@ function getAPI(extension, name, callbac
         extension, name, details.value);
     },
     async clear(details) {
       checkScope(details.scope);
       return await ExtensionPreferencesManager.removeSetting(
         extension, name);
     },
   };
-}
+};
 
 // Add settings objects for supported APIs to the preferences manager.
 ExtensionPreferencesManager.addSetting("network.networkPredictionEnabled", {
   prefNames: [
     "network.predictor.enabled",
     "network.prefetch-next",
     "network.http.speculative-parallel-limit",
     "network.dns.disablePrefetch",
@@ -139,30 +139,30 @@ ExtensionPreferencesManager.addSetting("
 });
 
 this.privacy = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       privacy: {
         network: {
-          networkPredictionEnabled: getAPI(extension,
+          networkPredictionEnabled: getPrivacyAPI(extension,
             "network.networkPredictionEnabled",
             () => {
               return Preferences.get("network.predictor.enabled") &&
                 Preferences.get("network.prefetch-next") &&
                 Preferences.get("network.http.speculative-parallel-limit") > 0 &&
                 !Preferences.get("network.dns.disablePrefetch");
             }),
-          peerConnectionEnabled: getAPI(extension,
+          peerConnectionEnabled: getPrivacyAPI(extension,
             "network.peerConnectionEnabled",
             () => {
               return Preferences.get("media.peerconnection.enabled");
             }),
-          webRTCIPHandlingPolicy: getAPI(extension,
+          webRTCIPHandlingPolicy: getPrivacyAPI(extension,
             "network.webRTCIPHandlingPolicy",
             () => {
               if (Preferences.get("media.peerconnection.ice.proxy_only")) {
                 return "disable_non_proxied_udp";
               }
 
               let default_address_only =
                 Preferences.get("media.peerconnection.ice.default_address_only");
@@ -173,30 +173,30 @@ this.privacy = class extends ExtensionAP
                 return "default_public_and_private_interfaces";
               }
 
               return "default";
             }),
         },
 
         services: {
-          passwordSavingEnabled: getAPI(extension,
+          passwordSavingEnabled: getPrivacyAPI(extension,
             "services.passwordSavingEnabled",
             () => {
               return Preferences.get("signon.rememberSignons");
             }),
         },
 
         websites: {
-          hyperlinkAuditingEnabled: getAPI(extension,
+          hyperlinkAuditingEnabled: getPrivacyAPI(extension,
             "websites.hyperlinkAuditingEnabled",
             () => {
               return Preferences.get("browser.send_pings");
             }),
-          referrersEnabled: getAPI(extension,
+          referrersEnabled: getPrivacyAPI(extension,
             "websites.referrersEnabled",
             () => {
               return Preferences.get("network.http.sendRefererHeader") !== 0;
             }),
         },
       },
     };
   }

--- a/toolkit/components/extensions/ext-protocolHandlers.js
+++ b/toolkit/components/extensions/ext-protocolHandlers.js
@@ -5,28 +5,28 @@
 XPCOMUtils.defineLazyServiceGetter(this, "handlerService",
                                    "@mozilla.org/uriloader/handler-service;1",
                                    "nsIHandlerService");
 XPCOMUtils.defineLazyServiceGetter(this, "protocolService",
                                    "@mozilla.org/uriloader/external-protocol-service;1",
                                    "nsIExternalProtocolService");
 Cu.importGlobalProperties(["URL"]);
 
-function hasHandlerApp(handlerConfig) {
+const hasHandlerApp = handlerConfig => {
   let protoInfo = protocolService.getProtocolHandlerInfo(handlerConfig.protocol);
   let appHandlers = protoInfo.possibleApplicationHandlers;
   for (let i = 0; i < appHandlers.length; i++) {
     let handler = appHandlers.queryElementAt(i, Ci.nsISupports);
     if (handler instanceof Ci.nsIWebHandlerApp &&
         handler.uriTemplate === handlerConfig.uriTemplate) {
       return true;
     }
   }
   return false;
-}
+};
 
 this.protocolHandlers = class extends ExtensionAPI {
   onManifestEntry(entryName) {
     let {extension} = this;
     let {manifest} = extension;
 
     for (let handlerConfig of manifest.protocol_handlers) {
       if (hasHandlerApp(handlerConfig)) {

--- a/toolkit/components/extensions/ext-storage.js
+++ b/toolkit/components/extensions/ext-storage.js
@@ -9,25 +9,25 @@ XPCOMUtils.defineLazyModuleGetter(this, 
                                   "resource://gre/modules/ExtensionStorageSync.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AddonManagerPrivate",
                                   "resource://gre/modules/AddonManager.jsm");
 
 var {
   ExtensionError,
 } = ExtensionUtils;
 
-function enforceNoTemporaryAddon(extensionId) {
+const enforceNoTemporaryAddon = extensionId => {
   const EXCEPTION_MESSAGE =
         "The storage API will not work with a temporary addon ID. " +
         "Please add an explicit addon ID to your manifest. " +
         "For more information see https://bugzil.la/1323228.";
   if (AddonManagerPrivate.isTemporaryInstallID(extensionId)) {
     throw new ExtensionError(EXCEPTION_MESSAGE);
   }
-}
+};
 
 this.storage = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       storage: {
         local: {
           get: function(spec) {

--- a/toolkit/components/extensions/ext-webNavigation.js
+++ b/toolkit/components/extensions/ext-webNavigation.js
@@ -31,21 +31,21 @@ const tabTransitions = {
     qualifiers: ["from_address_bar"],
     types: ["auto_bookmark", "typed", "keyword", "generated", "link"],
   },
   subFrame: {
     types: ["manual_subframe"],
   },
 };
 
-function isTopLevelFrame({frameId, parentFrameId}) {
+const isTopLevelFrame = ({frameId, parentFrameId}) => {
   return frameId == 0 && parentFrameId == -1;
-}
+};
 
-function fillTransitionProperties(eventName, src, dst) {
+const fillTransitionProperties = (eventName, src, dst) => {
   if (eventName == "onCommitted" ||
       eventName == "onHistoryStateUpdated" ||
       eventName == "onReferenceFragmentUpdated") {
     let frameTransitionData = src.frameTransitionData || {};
     let tabTransitionData = src.tabTransitionData || {};
 
     let transitionType, transitionQualifiers = [];
 
@@ -85,17 +85,17 @@ function fillTransitionProperties(eventN
       transitionType = tabTransitionData.link ?
         "manual_subframe" : defaultTransitionTypes.subFrame;
     }
 
     // Fill the transition properties in the webNavigation event object.
     dst.transitionType = transitionType;
     dst.transitionQualifiers = transitionQualifiers;
   }
-}
+};
 
 // Similar to WebRequestEventManager but for WebNavigation.
 function WebNavigationEventManager(context, eventName) {
   let name = `webNavigation.${eventName}`;
   let register = (fire, urlFilters) => {
     // Don't create a MatchURLFilters instance if the listener does not include any filter.
     let filters = urlFilters ?
           new MatchURLFilters(urlFilters.url) : null;
@@ -144,25 +144,25 @@ function WebNavigationEventManager(conte
     };
   };
 
   return SingletonEventManager.call(this, context, name, register);
 }
 
 WebNavigationEventManager.prototype = Object.create(SingletonEventManager.prototype);
 
-function convertGetFrameResult(tabId, data) {
+const convertGetFrameResult = (tabId, data) => {
   return {
     errorOccurred: data.errorOccurred,
     url: data.url,
     tabId,
     frameId: data.frameId,
     parentFrameId: data.parentFrameId,
   };
-}
+};
 
 this.webNavigation = class extends ExtensionAPI {
   getAPI(context) {
     let {tabManager} = context.extension;
 
     return {
       webNavigation: {
         onTabReplaced: new SingletonEventManager(context, "webNavigation.onTabReplaced", fire => {