--- a/browser/components/extensions/ext-bookmarks.js
+++ b/browser/components/extensions/ext-bookmarks.js
@@ -312,56 +312,56 @@ this.bookmarks = class extends Extension
           try {
             return PlacesUtils.bookmarks.remove(info).then(result => {})
               .catch(error => Promise.reject({message: error.message}));
           } catch (e) {
             return Promise.reject({message: `Invalid bookmark: ${JSON.stringify(info)}`});
           }
         },
 
-        onCreated: new SingletonEventManager(context, "bookmarks.onCreated", fire => {
+        onCreated: new EventManager(context, "bookmarks.onCreated", fire => {
           let listener = (event, bookmark) => {
             fire.sync(bookmark.id, bookmark);
           };
 
           observer.on("created", listener);
           incrementListeners();
           return () => {
             observer.off("created", listener);
             decrementListeners();
           };
         }).api(),
 
-        onRemoved: new SingletonEventManager(context, "bookmarks.onRemoved", fire => {
+        onRemoved: new EventManager(context, "bookmarks.onRemoved", fire => {
           let listener = (event, data) => {
             fire.sync(data.guid, data.info);
           };
 
           observer.on("removed", listener);
           incrementListeners();
           return () => {
             observer.off("removed", listener);
             decrementListeners();
           };
         }).api(),
 
-        onChanged: new SingletonEventManager(context, "bookmarks.onChanged", fire => {
+        onChanged: new EventManager(context, "bookmarks.onChanged", fire => {
           let listener = (event, data) => {
             fire.sync(data.guid, data.info);
           };
 
           observer.on("changed", listener);
           incrementListeners();
           return () => {
             observer.off("changed", listener);
             decrementListeners();
           };
         }).api(),
 
-        onMoved: new SingletonEventManager(context, "bookmarks.onMoved", fire => {
+        onMoved: new EventManager(context, "bookmarks.onMoved", fire => {
           let listener = (event, data) => {
             fire.sync(data.guid, data.info);
           };
 
           observer.on("moved", listener);
           incrementListeners();
           return () => {
             observer.off("moved", listener);

--- a/browser/components/extensions/ext-browserAction.js
+++ b/browser/components/extensions/ext-browserAction.js
@@ -545,17 +545,17 @@ this.browserAction = class extends Exten
       if (tabId !== null) {
         return tabTracker.getTab(tabId);
       }
       return null;
     }
 
     return {
       browserAction: {
-        onClicked: new SingletonEventManager(context, "browserAction.onClicked", fire => {
+        onClicked: new EventManager(context, "browserAction.onClicked", fire => {
           let listener = () => {
             fire.async(tabManager.convert(tabTracker.activeTab));
           };
           browserAction.on("click", listener);
           return () => {
             browserAction.off("click", listener);
           };
         }).api(),

--- a/browser/components/extensions/ext-c-devtools-panels.js
+++ b/browser/components/extensions/ext-c-devtools-panels.js
@@ -97,28 +97,28 @@ class ChildDevToolsPanel extends EventEm
   }
 
   onParentPanelHidden() {
     this.emit("hidden");
   }
 
   api() {
     return {
-      onShown: new SingletonEventManager(
+      onShown: new EventManager(
         this.context, "devtoolsPanel.onShown", fire => {
           const listener = (eventName, panelContentWindow) => {
             fire.asyncWithoutClone(panelContentWindow);
           };
           this.on("shown", listener);
           return () => {
             this.off("shown", listener);
           };
         }).api(),
 
-      onHidden: new SingletonEventManager(
+      onHidden: new EventManager(
         this.context, "devtoolsPanel.onHidden", fire => {
           const listener = () => {
             fire.async();
           };
           this.on("hidden", listener);
           return () => {
             this.off("hidden", listener);
           };
@@ -155,17 +155,17 @@ this.devtools_panels = class extends Ext
                                                     context.cloneScope,
                                                     {cloneFunctions: true});
               return devtoolsPanelAPI;
             });
           },
           get themeName() {
             return themeChangeObserver.themeName;
           },
-          onThemeChanged: new SingletonEventManager(
+          onThemeChanged: new EventManager(
             context, "devtools.panels.onThemeChanged", fire => {
               const listener = (eventName, themeName) => {
                 fire.async(themeName);
               };
               themeChangeObserver.on("themeChanged", listener);
               return () => {
                 themeChangeObserver.off("themeChanged", listener);
               };

--- a/browser/components/extensions/ext-c-menus.js
+++ b/browser/components/extensions/ext-c-menus.js
@@ -153,17 +153,17 @@ this.menusInternal = class extends Exten
         },
 
         removeAll() {
           onClickedProp.deleteAllListenersFromExtension();
 
           return context.childManager.callParentAsyncFunction("menusInternal.removeAll", []);
         },
 
-        onClicked: new SingletonEventManager(context, "menus.onClicked", fire => {
+        onClicked: new EventManager(context, "menus.onClicked", fire => {
           let listener = (info, tab) => {
             fire.async(info, tab);
           };
 
           let event = context.childManager.getParentEvent("menusInternal.onClicked");
           event.addListener(listener);
           return () => {
             event.removeListener(listener);

--- a/browser/components/extensions/ext-c-omnibox.js
+++ b/browser/components/extensions/ext-c-omnibox.js
@@ -4,17 +4,17 @@
 
 // The ext-* files are imported into the same scopes.
 /* import-globals-from ../../../toolkit/components/extensions/ext-c-toolkit.js */
 
 this.omnibox = class extends ExtensionAPI {
   getAPI(context) {
     return {
       omnibox: {
-        onInputChanged: new SingletonEventManager(context, "omnibox.onInputChanged", fire => {
+        onInputChanged: new EventManager(context, "omnibox.onInputChanged", fire => {
           let listener = (text, id) => {
             fire.asyncWithoutClone(text, suggestions => {
               context.childManager.callParentFunctionNoReturn("omnibox_internal.addSuggestions", [
                 id,
                 suggestions,
               ]);
             });
           };

--- a/browser/components/extensions/ext-commands.js
+++ b/browser/components/extensions/ext-commands.js
@@ -236,17 +236,17 @@ this.commands = class extends ExtensionA
           return Promise.resolve(Array.from(commands, ([name, command]) => {
             return ({
               name,
               description: command.description,
               shortcut: command.shortcut,
             });
           }));
         },
-        onCommand: new SingletonEventManager(context, "commands.onCommand", fire => {
+        onCommand: new EventManager(context, "commands.onCommand", fire => {
           let listener = (eventName, commandName) => {
             fire.async(commandName);
           };
           this.on("command", listener);
           return () => {
             this.off("command", listener);
           };
         }).api(),

--- a/browser/components/extensions/ext-devtools-network.js
+++ b/browser/components/extensions/ext-devtools-network.js
@@ -5,17 +5,17 @@
 // The ext-* files are imported into the same scopes.
 /* import-globals-from ext-devtools.js */
 
 this.devtools_network = class extends ExtensionAPI {
   getAPI(context) {
     return {
       devtools: {
         network: {
-          onNavigated: new SingletonEventManager(context, "devtools.onNavigated", fire => {
+          onNavigated: new EventManager(context, "devtools.onNavigated", fire => {
             let listener = (event, data) => {
               fire.async(data.url);
             };
 
             let targetPromise = getDevToolsTargetForContext(context);
             targetPromise.then(target => {
               target.on("navigate", listener);
             });

--- a/browser/components/extensions/ext-geckoProfiler.js
+++ b/browser/components/extensions/ext-geckoProfiler.js
@@ -369,17 +369,17 @@ this.geckoProfiler = class extends Exten
               // known system library.
               // "nm" will fail if `nm` is not available.
             }
           }
 
           throw new Error(`Ran out of options to get symbols from library ${debugName} ${breakpadId}.`);
         },
 
-        onRunning: new SingletonEventManager(context, "geckoProfiler.onRunning", fire => {
+        onRunning: new EventManager(context, "geckoProfiler.onRunning", fire => {
           isRunningObserver.addObserver(fire.async);
           return () => {
             isRunningObserver.removeObserver(fire.async);
           };
         }).api(),
       },
     };
   }

--- a/browser/components/extensions/ext-history.js
+++ b/browser/components/extensions/ext-history.js
@@ -214,39 +214,39 @@ this.history = class extends ExtensionAP
 
           let historyQuery = PlacesUtils.history.getNewQuery();
           historyQuery.uri = NetUtil.newURI(url);
           let queryResult = PlacesUtils.history.executeQuery(historyQuery, options).root;
           let results = convertNavHistoryContainerResultNode(queryResult, convertNodeToVisitItem);
           return Promise.resolve(results);
         },
 
-        onVisited: new SingletonEventManager(context, "history.onVisited", fire => {
+        onVisited: new EventManager(context, "history.onVisited", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
           getObserver().on("visited", listener);
           return () => {
             getObserver().off("visited", listener);
           };
         }).api(),
 
-        onVisitRemoved: new SingletonEventManager(context, "history.onVisitRemoved", fire => {
+        onVisitRemoved: new EventManager(context, "history.onVisitRemoved", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
           getObserver().on("visitRemoved", listener);
           return () => {
             getObserver().off("visitRemoved", listener);
           };
         }).api(),
 
-        onTitleChanged: new SingletonEventManager(context, "history.onTitleChanged", fire => {
+        onTitleChanged: new EventManager(context, "history.onTitleChanged", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
           getObserver().on("titleChanged", listener);
           return () => {
             getObserver().off("titleChanged", listener);
           };

--- a/browser/components/extensions/ext-menus.js
+++ b/browser/components/extensions/ext-menus.js
@@ -667,17 +667,17 @@ this.menusInternal = class extends Exten
 
         removeAll: function() {
           let root = gRootItems.get(extension);
           if (root) {
             root.remove();
           }
         },
 
-        onClicked: new SingletonEventManager(context, "menusInternal.onClicked", fire => {
+        onClicked: new EventManager(context, "menusInternal.onClicked", fire => {
           let listener = (event, info, tab) => {
             fire.async(info, tab);
           };
 
           extension.on("webext-menu-menuitem-click", listener);
           return () => {
             extension.off("webext-menu-menuitem-click", listener);
           };

--- a/browser/components/extensions/ext-omnibox.js
+++ b/browser/components/extensions/ext-omnibox.js
@@ -35,37 +35,37 @@ this.omnibox = class extends ExtensionAP
           try {
             // This will throw if the keyword failed to register.
             ExtensionSearchHandler.setDefaultSuggestion(this.keyword, suggestion);
           } catch (e) {
             return Promise.reject(e.message);
           }
         },
 
-        onInputStarted: new SingletonEventManager(context, "omnibox.onInputStarted", fire => {
+        onInputStarted: new EventManager(context, "omnibox.onInputStarted", fire => {
           let listener = (eventName) => {
             fire.sync();
           };
           extension.on(ExtensionSearchHandler.MSG_INPUT_STARTED, listener);
           return () => {
             extension.off(ExtensionSearchHandler.MSG_INPUT_STARTED, listener);
           };
         }).api(),
 
-        onInputCancelled: new SingletonEventManager(context, "omnibox.onInputCancelled", fire => {
+        onInputCancelled: new EventManager(context, "omnibox.onInputCancelled", fire => {
           let listener = (eventName) => {
             fire.sync();
           };
           extension.on(ExtensionSearchHandler.MSG_INPUT_CANCELLED, listener);
           return () => {
             extension.off(ExtensionSearchHandler.MSG_INPUT_CANCELLED, listener);
           };
         }).api(),
 
-        onInputEntered: new SingletonEventManager(context, "omnibox.onInputEntered", fire => {
+        onInputEntered: new EventManager(context, "omnibox.onInputEntered", fire => {
           let listener = (eventName, text, disposition) => {
             fire.sync(text, disposition);
           };
           extension.on(ExtensionSearchHandler.MSG_INPUT_ENTERED, listener);
           return () => {
             extension.off(ExtensionSearchHandler.MSG_INPUT_ENTERED, listener);
           };
         }).api(),
@@ -76,17 +76,17 @@ this.omnibox = class extends ExtensionAP
           try {
             ExtensionSearchHandler.addSuggestions(this.keyword, id, suggestions);
           } catch (e) {
             // Silently fail because the extension developer can not know for sure if the user
             // has already invalidated the callback when asynchronously providing suggestions.
           }
         },
 
-        onInputChanged: new SingletonEventManager(context, "omnibox_internal.onInputChanged", fire => {
+        onInputChanged: new EventManager(context, "omnibox_internal.onInputChanged", fire => {
           let listener = (eventName, text, id) => {
             fire.sync(text, id);
           };
           extension.on(ExtensionSearchHandler.MSG_INPUT_CHANGED, listener);
           return () => {
             extension.off(ExtensionSearchHandler.MSG_INPUT_CHANGED, listener);
           };
         }).api(),

--- a/browser/components/extensions/ext-pageAction.js
+++ b/browser/components/extensions/ext-pageAction.js
@@ -263,17 +263,17 @@ this.pageAction = class extends Extensio
   getAPI(context) {
     let {extension} = context;
 
     const {tabManager} = extension;
     const pageAction = this;
 
     return {
       pageAction: {
-        onClicked: new SingletonEventManager(context, "pageAction.onClicked", fire => {
+        onClicked: new EventManager(context, "pageAction.onClicked", fire => {
           let listener = (evt, tab) => {
             fire.async(tabManager.convert(tab));
           };
 
           pageAction.on("click", listener);
           return () => {
             pageAction.off("click", listener);
           };

--- a/browser/components/extensions/ext-sessions.js
+++ b/browser/components/extensions/ext-sessions.js
@@ -122,17 +122,17 @@ this.sessions = class extends ExtensionA
 
             // Use the closedId of the most recently closed tab to restore it.
             closedId = recentlyClosedTabs[0].closedId;
             session = SessionStore.undoCloseById(closedId);
           }
           return createSession(session, extension, closedId);
         },
 
-        onChanged: new SingletonEventManager(context, "sessions.onChanged", fire => {
+        onChanged: new EventManager(context, "sessions.onChanged", fire => {
           let observer = () => {
             fire.async();
           };
 
           Services.obs.addObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED);
           return () => {
             Services.obs.removeObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED);
           };

--- a/browser/components/extensions/ext-tabs.js
+++ b/browser/components/extensions/ext-tabs.js
@@ -95,93 +95,93 @@ this.tabs = class extends ExtensionAPI {
 
       await tabListener.awaitTabReady(tab.nativeTab);
 
       return tab;
     }
 
     let self = {
       tabs: {
-        onActivated: new SingletonEventManager(context, "tabs.onActivated", fire => {
+        onActivated: new EventManager(context, "tabs.onActivated", fire => {
           let listener = (eventName, event) => {
             fire.async(event);
           };
 
           tabTracker.on("tab-activated", listener);
           return () => {
             tabTracker.off("tab-activated", listener);
           };
         }).api(),
 
-        onCreated: new SingletonEventManager(context, "tabs.onCreated", fire => {
+        onCreated: new EventManager(context, "tabs.onCreated", fire => {
           let listener = (eventName, event) => {
             fire.async(tabManager.convert(event.nativeTab, event.currentTab));
           };
 
           tabTracker.on("tab-created", listener);
           return () => {
             tabTracker.off("tab-created", listener);
           };
         }).api(),
 
         /**
          * Since multiple tabs currently can't be highlighted, onHighlighted
          * essentially acts an alias for self.tabs.onActivated but returns
          * the tabId in an array to match the API.
          * @see  https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/Tabs/onHighlighted
         */
-        onHighlighted: new SingletonEventManager(context, "tabs.onHighlighted", fire => {
+        onHighlighted: new EventManager(context, "tabs.onHighlighted", fire => {
           let listener = (eventName, event) => {
             fire.async({tabIds: [event.tabId], windowId: event.windowId});
           };
 
           tabTracker.on("tab-activated", listener);
           return () => {
             tabTracker.off("tab-activated", listener);
           };
         }).api(),
 
-        onAttached: new SingletonEventManager(context, "tabs.onAttached", fire => {
+        onAttached: new EventManager(context, "tabs.onAttached", fire => {
           let listener = (eventName, event) => {
             fire.async(event.tabId, {newWindowId: event.newWindowId, newPosition: event.newPosition});
           };
 
           tabTracker.on("tab-attached", listener);
           return () => {
             tabTracker.off("tab-attached", listener);
           };
         }).api(),
 
-        onDetached: new SingletonEventManager(context, "tabs.onDetached", fire => {
+        onDetached: new EventManager(context, "tabs.onDetached", fire => {
           let listener = (eventName, event) => {
             fire.async(event.tabId, {oldWindowId: event.oldWindowId, oldPosition: event.oldPosition});
           };
 
           tabTracker.on("tab-detached", listener);
           return () => {
             tabTracker.off("tab-detached", listener);
           };
         }).api(),
 
-        onRemoved: new SingletonEventManager(context, "tabs.onRemoved", fire => {
+        onRemoved: new EventManager(context, "tabs.onRemoved", fire => {
           let listener = (eventName, event) => {
             fire.async(event.tabId, {windowId: event.windowId, isWindowClosing: event.isWindowClosing});
           };
 
           tabTracker.on("tab-removed", listener);
           return () => {
             tabTracker.off("tab-removed", listener);
           };
         }).api(),
 
-        onReplaced: new SingletonEventManager(context, "tabs.onReplaced", fire => {
+        onReplaced: new EventManager(context, "tabs.onReplaced", fire => {
           return () => {};
         }).api(),
 
-        onMoved: new SingletonEventManager(context, "tabs.onMoved", fire => {
+        onMoved: new EventManager(context, "tabs.onMoved", fire => {
           // There are certain circumstances where we need to ignore a move event.
           //
           // Namely, the first time the tab is moved after it's created, we need
           // to report the final position as the initial position in the tab's
           // onAttached or onCreated event. This is because most tabs are inserted
           // in a temporary location and then moved after the TabOpen event fires,
           // which generates a TabOpen event followed by a TabMove event, which
           // does not match the contract of our API.
@@ -214,17 +214,17 @@ this.tabs = class extends ExtensionAPI {
           windowTracker.addListener("TabMove", moveListener);
           windowTracker.addListener("TabOpen", openListener);
           return () => {
             windowTracker.removeListener("TabMove", moveListener);
             windowTracker.removeListener("TabOpen", openListener);
           };
         }).api(),
 
-        onUpdated: new SingletonEventManager(context, "tabs.onUpdated", fire => {
+        onUpdated: new EventManager(context, "tabs.onUpdated", fire => {
           const restricted = ["url", "favIconUrl", "title"];
 
           function sanitize(extension, changeInfo) {
             let result = {};
             let nonempty = false;
             for (let prop in changeInfo) {
               if (extension.hasPermission("tabs") || !restricted.includes(prop)) {
                 nonempty = true;
@@ -674,17 +674,17 @@ this.tabs = class extends ExtensionAPI {
           let currentSettings = this._getZoomSettings(tabTracker.getId(nativeTab));
 
           if (!Object.keys(settings).every(key => settings[key] === currentSettings[key])) {
             return Promise.reject(`Unsupported zoom settings: ${JSON.stringify(settings)}`);
           }
           return Promise.resolve();
         },
 
-        onZoomChange: new SingletonEventManager(context, "tabs.onZoomChange", fire => {
+        onZoomChange: new EventManager(context, "tabs.onZoomChange", fire => {
           let getZoomLevel = browser => {
             let {ZoomManager} = browser.ownerGlobal;
 
             return ZoomManager.getZoomForBrowser(browser);
           };
 
           // Stores the last known zoom level for each tab's browser.
           // WeakMap[<browser> -> number]

--- a/browser/components/extensions/ext-utils.js
+++ b/browser/components/extensions/ext-utils.js
@@ -117,17 +117,17 @@ class WindowTracker extends WindowTracke
  *        The extension context which the event manager belongs to.
  * @param {string} name
  *        The API name of the event manager, e.g.,"runtime.onMessage".
  * @param {string} event
  *        The name of the DOM event to listen for.
  * @param {function} listener
  *        The listener function to call when a DOM event is received.
  */
-global.WindowEventManager = class extends SingletonEventManager {
+global.WindowEventManager = class extends EventManager {
   constructor(context, name, event, listener) {
     super(context, name, fire => {
       let listener2 = listener.bind(null, fire);
 
       windowTracker.addListener(event, listener2);
       return () => {
         windowTracker.removeListener(event, listener2);
       };

--- a/browser/components/extensions/ext-windows.js
+++ b/browser/components/extensions/ext-windows.js
@@ -34,17 +34,17 @@ this.windows = class extends ExtensionAP
           fire.async(windowManager.convert(window));
         }).api(),
 
         onRemoved:
         new WindowEventManager(context, "windows.onRemoved", "domwindowclosed", (fire, window) => {
           fire.async(windowTracker.getId(window));
         }).api(),
 
-        onFocusChanged: new SingletonEventManager(context, "windows.onFocusChanged", fire => {
+        onFocusChanged: new EventManager(context, "windows.onFocusChanged", fire => {
           // Keep track of the last windowId used to fire an onFocusChanged event
           let lastOnFocusChangedWindowId;
 
           let listener = event => {
             // Wait a tick to avoid firing a superfluous WINDOW_ID_NONE
             // event when switching focus between two Firefox windows.
             Promise.resolve().then(() => {
               let window = Services.focus.activeWindow;

--- a/mobile/android/components/extensions/ext-browserAction.js
+++ b/mobile/android/components/extensions/ext-browserAction.js
@@ -142,17 +142,17 @@ this.browserAction = class extends Exten
   }
 
   getAPI(context) {
     const {extension} = context;
     const {tabManager} = extension;
 
     return {
       browserAction: {
-        onClicked: new SingletonEventManager(context, "browserAction.onClicked", fire => {
+        onClicked: new EventManager(context, "browserAction.onClicked", fire => {
           let listener = (event, tab) => {
             fire.async(tabManager.convert(tab));
           };
           browserActionMap.get(extension).on("click", listener);
           return () => {
             browserActionMap.get(extension).off("click", listener);
           };
         }).api(),

--- a/mobile/android/components/extensions/ext-pageAction.js
+++ b/mobile/android/components/extensions/ext-pageAction.js
@@ -221,17 +221,17 @@ this.pageAction = class extends Extensio
   getAPI(context) {
     const {extension} = context;
     const {tabManager} = extension;
 
     pageActionMap.get(extension).setContext(context);
 
     return {
       pageAction: {
-        onClicked: new SingletonEventManager(context, "pageAction.onClicked", fire => {
+        onClicked: new EventManager(context, "pageAction.onClicked", fire => {
           let listener = (event, tab) => {
             fire.async(tabManager.convert(tab));
           };
           pageActionMap.get(extension).on("click", listener);
           return () => {
             pageActionMap.get(extension).off("click", listener);
           };
         }).api(),

--- a/mobile/android/components/extensions/ext-tabs.js
+++ b/mobile/android/components/extensions/ext-tabs.js
@@ -106,17 +106,17 @@ this.tabs = class extends ExtensionAPI {
     let self = {
       tabs: {
         onActivated: new GlobalEventManager(context, "tabs.onActivated", "Tab:Selected", (fire, data) => {
           let tab = tabManager.get(data.id);
 
           fire.async({tabId: tab.id, windowId: tab.windowId});
         }).api(),
 
-        onCreated: new SingletonEventManager(context, "tabs.onCreated", fire => {
+        onCreated: new EventManager(context, "tabs.onCreated", fire => {
           let listener = (eventName, event) => {
             fire.async(tabManager.convert(event.nativeTab));
           };
 
           tabTracker.on("tab-created", listener);
           return () => {
             tabTracker.off("tab-created", listener);
           };
@@ -129,44 +129,44 @@ this.tabs = class extends ExtensionAPI {
          * @see  https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/Tabs/onHighlighted
         */
         onHighlighted: new GlobalEventManager(context, "tabs.onHighlighted", "Tab:Selected", (fire, data) => {
           let tab = tabManager.get(data.id);
 
           fire.async({tabIds: [tab.id], windowId: tab.windowId});
         }).api(),
 
-        onAttached: new SingletonEventManager(context, "tabs.onAttached", fire => {
+        onAttached: new EventManager(context, "tabs.onAttached", fire => {
           return () => {};
         }).api(),
 
-        onDetached: new SingletonEventManager(context, "tabs.onDetached", fire => {
+        onDetached: new EventManager(context, "tabs.onDetached", fire => {
           return () => {};
         }).api(),
 
-        onRemoved: new SingletonEventManager(context, "tabs.onRemoved", fire => {
+        onRemoved: new EventManager(context, "tabs.onRemoved", fire => {
           let listener = (eventName, event) => {
             fire.async(event.tabId, {windowId: event.windowId, isWindowClosing: event.isWindowClosing});
           };
 
           tabTracker.on("tab-removed", listener);
           return () => {
             tabTracker.off("tab-removed", listener);
           };
         }).api(),
 
-        onReplaced: new SingletonEventManager(context, "tabs.onReplaced", fire => {
+        onReplaced: new EventManager(context, "tabs.onReplaced", fire => {
           return () => {};
         }).api(),
 
-        onMoved: new SingletonEventManager(context, "tabs.onMoved", fire => {
+        onMoved: new EventManager(context, "tabs.onMoved", fire => {
           return () => {};
         }).api(),
 
-        onUpdated: new SingletonEventManager(context, "tabs.onUpdated", fire => {
+        onUpdated: new EventManager(context, "tabs.onUpdated", fire => {
           const restricted = ["url", "favIconUrl", "title"];
 
           function sanitize(extension, changeInfo) {
             let result = {};
             let nonempty = false;
             for (let prop in changeInfo) {
               if (extension.hasPermission("tabs") || !restricted.includes(prop)) {
                 nonempty = true;

--- a/mobile/android/components/extensions/ext-utils.js
+++ b/mobile/android/components/extensions/ext-utils.js
@@ -200,17 +200,17 @@ class WindowTracker extends WindowTracke
  * @param {string} name
  *        The API name of the event manager, e.g.,"runtime.onMessage".
  * @param {string} event
  *        The name of the EventDispatcher event to listen for.
  * @param {function} listener
  *        The listener function to call when an EventDispatcher event is
  *        recieved.
  */
-global.GlobalEventManager = class extends SingletonEventManager {
+global.GlobalEventManager = class extends EventManager {
   constructor(context, name, event, listener) {
     super(context, name, fire => {
       let listener2 = {
         onEvent(event, data, callback) {
           listener(fire, data);
         },
       };
 
@@ -232,17 +232,17 @@ global.GlobalEventManager = class extend
  *        The extension context which the event manager belongs to.
  * @param {string} name
  *        The API name of the event manager, e.g.,"runtime.onMessage".
  * @param {string} event
  *        The name of the DOM event to listen for.
  * @param {function} listener
  *        The listener function to call when a DOM event is received.
  */
-global.WindowEventManager = class extends SingletonEventManager {
+global.WindowEventManager = class extends EventManager {
   constructor(context, name, event, listener) {
     super(context, name, fire => {
       let listener2 = listener.bind(null, fire);
 
       windowTracker.addListener(event, listener2);
       return () => {
         windowTracker.removeListener(event, listener2);
       };

--- a/toolkit/components/extensions/ExtensionChild.jsm
+++ b/toolkit/components/extensions/ExtensionChild.jsm
@@ -41,21 +41,21 @@ const {
   EventEmitter,
   LimitedSet,
   defineLazyGetter,
   getMessageManager,
   getUniqueId,
 } = ExtensionUtils;
 
 const {
+  EventManager,
   LocalAPIImplementation,
   LocaleData,
   NoCloneSpreadArgs,
   SchemaAPIInterface,
-  SingletonEventManager,
 } = ExtensionCommon;
 
 const isContentProcess = Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT;
 
 // Copy an API object from |source| into the scope |dest|.
 function injectAPI(source, dest) {
   for (let prop in source) {
     // Skip names prefixed with '_'.
@@ -128,25 +128,25 @@ class Port {
       disconnect: () => {
         this.disconnect();
       },
 
       postMessage: json => {
         this.postMessage(json);
       },
 
-      onDisconnect: new SingletonEventManager(this.context, "Port.onDisconnect", fire => {
+      onDisconnect: new EventManager(this.context, "Port.onDisconnect", fire => {
         return this.registerOnDisconnect(holder => {
           let error = holder.deserialize(this.context.cloneScope);
           portError = error && this.context.normalizeError(error);
           fire.asyncWithoutClone(portObj);
         });
       }).api(),
 
-      onMessage: new SingletonEventManager(this.context, "Port.onMessage", fire => {
+      onMessage: new EventManager(this.context, "Port.onMessage", fire => {
         return this.registerOnMessage(holder => {
           let msg = holder.deserialize(this.context.cloneScope);
           fire.asyncWithoutClone(msg, portObj);
         });
       }).api(),
 
       get error() {
         return portError;
@@ -344,17 +344,17 @@ class Messenger {
   }
 
   sendNativeMessage(messageManager, msg, recipient, responseCallback) {
     msg = NativeApp.encodeMessage(this.context, msg);
     return this.sendMessage(messageManager, msg, recipient, responseCallback);
   }
 
   _onMessage(name, filter) {
-    return new SingletonEventManager(this.context, name, fire => {
+    return new EventManager(this.context, name, fire => {
       let listener = {
         messageFilterPermissive: this.optionalFilter,
         messageFilterStrict: this.filter,
 
         filterMessage: (sender, recipient) => {
           // Ignore the message if it was sent by this Messenger.
           return (sender.contextId !== this.context.contextId &&
                   filter(sender, recipient));
@@ -435,17 +435,17 @@ class Messenger {
     let portId = getUniqueId();
 
     let port = new NativePort(this.context, messageManager, this.messageManagers, name, portId, null, recipient);
 
     return this._connect(messageManager, port, recipient);
   }
 
   _onConnect(name, filter) {
-    return new SingletonEventManager(this.context, name, fire => {
+    return new EventManager(this.context, name, fire => {
       let listener = {
         messageFilterPermissive: this.optionalFilter,
         messageFilterStrict: this.filter,
 
         filterMessage: (sender, recipient) => {
           // Ignore the port if it was created by this Messenger.
           return (sender.contextId !== this.context.contextId &&
                   filter(sender, recipient));

--- a/toolkit/components/extensions/ExtensionCommon.jsm
+++ b/toolkit/components/extensions/ExtensionCommon.jsm
@@ -1354,17 +1354,17 @@ LocaleData.prototype = {
 
 defineLazyGetter(LocaleData.prototype, "availableLocales", function() {
   return new Set([this.BUILTIN, this.selectedLocale, this.defaultLocale]
                  .filter(locale => this.messages.has(locale)));
 });
 
 // This is a generic class for managing event listeners. Example usage:
 //
-// new SingletonEventManager(context, "api.subAPI", fire => {
+// new EventManager(context, "api.subAPI", fire => {
 //   let listener = (...) => {
 //     // Fire any listeners registered with addListener.
 //     fire.async(arg1, arg2);
 //   };
 //   // Register the listener.
 //   SomehowRegisterListener(listener);
 //   return () => {
 //     // Return a way to unregister the listener.
@@ -1373,24 +1373,24 @@ defineLazyGetter(LocaleData.prototype, "
 // }).api()
 //
 // The result is an object with addListener, removeListener, and
 // hasListener methods. |context| is an add-on scope (either an
 // ExtensionContext in the chrome process or ExtensionContext in a
 // content process). |name| is for debugging. |register| is a function
 // to register the listener. |register| should return an
 // unregister function that will unregister the listener.
-function SingletonEventManager(context, name, register) {
+function EventManager(context, name, register) {
   this.context = context;
   this.name = name;
   this.register = register;
   this.unregister = new Map();
 }
 
-SingletonEventManager.prototype = {
+EventManager.prototype = {
   addListener(callback, ...args) {
     if (this.unregister.has(callback)) {
       return;
     }
 
     let shouldFire = () => {
       if (this.context.unloaded) {
         dump(`${this.name} event fired after context unloaded.\n`);
@@ -1503,18 +1503,18 @@ const stylesheetMap = new DefaultMap(url
   let uri = Services.io.newURI(url);
   return styleSheetService.preloadSheet(uri, styleSheetService.AGENT_SHEET);
 });
 
 
 ExtensionCommon = {
   BaseContext,
   CanOfAPIs,
+  EventManager,
   LocalAPIImplementation,
   LocaleData,
   NoCloneSpreadArgs,
   SchemaAPIInterface,
   SchemaAPIManager,
-  SingletonEventManager,
   SpreadArgs,
   ignoreEvent,
   stylesheetMap,
 };

--- a/toolkit/components/extensions/ext-alarms.js
+++ b/toolkit/components/extensions/ext-alarms.js
@@ -131,17 +131,17 @@ this.alarms = class extends ExtensionAPI
           let cleared = false;
           for (let alarm of alarmsMap.get(extension).values()) {
             alarm.clear();
             cleared = true;
           }
           return Promise.resolve(cleared);
         },
 
-        onAlarm: new SingletonEventManager(context, "alarms.onAlarm", fire => {
+        onAlarm: new EventManager(context, "alarms.onAlarm", fire => {
           let callback = alarm => {
             fire.sync(alarm.data);
           };
 
           alarmCallbacksMap.get(extension).add(callback);
           return () => {
             alarmCallbacksMap.get(extension).delete(callback);
           };

--- a/toolkit/components/extensions/ext-c-test.js
+++ b/toolkit/components/extensions/ext-c-test.js
@@ -163,17 +163,17 @@ this.test = class extends ExtensionAPI {
             let errorMessage = toSource(error && error.message);
 
             assertTrue(errorMatches(error, expectedError, context),
                        `Function threw, expecting error to match ${toSource(expectedError)}` +
                        `got ${errorMessage}${msg}`);
           }
         },
 
-        onMessage: new SingletonEventManager(context, "test.onMessage", fire => {
+        onMessage: new EventManager(context, "test.onMessage", fire => {
           let handler = (event, ...args) => {
             fire.async(...args);
           };
 
           extension.on("test-harness-message", handler);
           return () => {
             extension.off("test-harness-message", handler);
           };

--- a/toolkit/components/extensions/ext-c-toolkit.js
+++ b/toolkit/components/extensions/ext-c-toolkit.js
@@ -1,18 +1,18 @@
 "use strict";
 
 Cu.import("resource://gre/modules/ExtensionCommon.jsm");
 
 // These are defined on "global" which is used for the same scopes as the other
 // ext-c-*.js files.
-/* exported SingletonEventManager */
-/* global SingletonEventManager: false */
+/* exported EventManager */
+/* global EventManager: false */
 
-global.SingletonEventManager = ExtensionCommon.SingletonEventManager;
+global.EventManager = ExtensionCommon.EventManager;
 
 global.initializeBackgroundPage = (contentWindow) => {
   // Override the `alert()` method inside background windows;
   // we alias it to console.log().
   // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1203394
   let alertDisplayedWarning = false;
   let alertOverwrite = text => {
     if (!alertDisplayedWarning) {

--- a/toolkit/components/extensions/ext-cookies.js
+++ b/toolkit/components/extensions/ext-cookies.js
@@ -373,17 +373,17 @@ this.cookies = class extends ExtensionAP
 
           let result = [];
           for (let key in data) {
             result.push({id: key, tabIds: data[key], incognito: key == PRIVATE_STORE});
           }
           return Promise.resolve(result);
         },
 
-        onChanged: new SingletonEventManager(context, "cookies.onChanged", fire => {
+        onChanged: new EventManager(context, "cookies.onChanged", fire => {
           let observer = (subject, topic, data) => {
             let notify = (removed, cookie, cause) => {
               cookie.QueryInterface(Ci.nsICookie2);
 
               if (extension.whiteListedHosts.matchesCookie(cookie)) {
                 fire.async({removed, cookie: convert({cookie, isPrivate: topic == "private-cookie-changed"}), cause});
               }
             };

--- a/toolkit/components/extensions/ext-downloads.js
+++ b/toolkit/components/extensions/ext-downloads.js
@@ -733,17 +733,17 @@ this.downloads = class extends Extension
         // i.e.:
         // setShelfEnabled(enabled) {
         //   if (!extension.hasPermission("downloads.shelf")) {
         //     throw new context.cloneScope.Error("Permission denied because 'downloads.shelf' permission is missing.");
         //   }
         //   ...
         // }
 
-        onChanged: new SingletonEventManager(context, "downloads.onChanged", fire => {
+        onChanged: new EventManager(context, "downloads.onChanged", fire => {
           const handler = (what, item) => {
             let changes = {};
             const noundef = val => (val === undefined) ? null : val;
             DOWNLOAD_ITEM_CHANGE_FIELDS.forEach(fld => {
               if (item[fld] != item.prechange[fld]) {
                 changes[fld] = {
                   previous: noundef(item.prechange[fld]),
                   current: noundef(item[fld]),
@@ -761,31 +761,31 @@ this.downloads = class extends Extension
           });
           return () => {
             registerPromise.then(() => {
               DownloadMap.off("change", handler);
             });
           };
         }).api(),
 
-        onCreated: new SingletonEventManager(context, "downloads.onCreated", fire => {
+        onCreated: new EventManager(context, "downloads.onCreated", fire => {
           const handler = (what, item) => {
             fire.async(item.serialize());
           };
           let registerPromise = DownloadMap.getDownloadList().then(() => {
             DownloadMap.on("create", handler);
           });
           return () => {
             registerPromise.then(() => {
               DownloadMap.off("create", handler);
             });
           };
         }).api(),
 
-        onErased: new SingletonEventManager(context, "downloads.onErased", fire => {
+        onErased: new EventManager(context, "downloads.onErased", fire => {
           const handler = (what, item) => {
             fire.async(item.id);
           };
           let registerPromise = DownloadMap.getDownloadList().then(() => {
             DownloadMap.on("erase", handler);
           });
           return () => {
             registerPromise.then(() => {

--- a/toolkit/components/extensions/ext-idle.js
+++ b/toolkit/components/extensions/ext-idle.js
@@ -71,17 +71,17 @@ this.idle = class extends ExtensionAPI {
           if (idleService.idleTime < detectionIntervalInSeconds * 1000) {
             return Promise.resolve("active");
           }
           return Promise.resolve("idle");
         },
         setDetectionInterval: function(detectionIntervalInSeconds) {
           setDetectionInterval(extension, context, detectionIntervalInSeconds);
         },
-        onStateChanged: new SingletonEventManager(context, "idle.onStateChanged", fire => {
+        onStateChanged: new EventManager(context, "idle.onStateChanged", fire => {
           let listener = (event, data) => {
             fire.sync(data);
           };
 
           getObserver(extension, context).on("stateChanged", listener);
           return () => {
             getObserver(extension, context).off("stateChanged", listener);
           };

--- a/toolkit/components/extensions/ext-management.js
+++ b/toolkit/components/extensions/ext-management.js
@@ -219,50 +219,50 @@ this.management = class extends Extensio
             throw new ExtensionError("setEnabled applies only to theme addons");
           }
           if (addon.isSystem) {
             throw new ExtensionError("setEnabled cannot be used with a system addon");
           }
           addon.userDisabled = !enabled;
         },
 
-        onDisabled: new SingletonEventManager(context, "management.onDisabled", fire => {
+        onDisabled: new EventManager(context, "management.onDisabled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
           getListener(extension, context).on("onDisabled", listener);
           return () => {
             getListener(extension, context).off("onDisabled", listener);
           };
         }).api(),
 
-        onEnabled: new SingletonEventManager(context, "management.onEnabled", fire => {
+        onEnabled: new EventManager(context, "management.onEnabled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
           getListener(extension, context).on("onEnabled", listener);
           return () => {
             getListener(extension, context).off("onEnabled", listener);
           };
         }).api(),
 
-        onInstalled: new SingletonEventManager(context, "management.onInstalled", fire => {
+        onInstalled: new EventManager(context, "management.onInstalled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
           getListener(extension, context).on("onInstalled", listener);
           return () => {
             getListener(extension, context).off("onInstalled", listener);
           };
         }).api(),
 
-        onUninstalled: new SingletonEventManager(context, "management.onUninstalled", fire => {
+        onUninstalled: new EventManager(context, "management.onUninstalled", fire => {
           let listener = (event, data) => {
             fire.async(data);
           };
 
           getListener(extension, context).on("onUninstalled", listener);
           return () => {
             getListener(extension, context).off("onUninstalled", listener);
           };

--- a/toolkit/components/extensions/ext-notifications.js
+++ b/toolkit/components/extensions/ext-notifications.js
@@ -128,29 +128,29 @@ this.notifications = class extends Exten
         getAll: function() {
           let result = {};
           notificationsMap.get(extension).forEach((value, key) => {
             result[key] = value.options;
           });
           return Promise.resolve(result);
         },
 
-        onClosed: new SingletonEventManager(context, "notifications.onClosed", fire => {
+        onClosed: new EventManager(context, "notifications.onClosed", fire => {
           let listener = (event, notificationId) => {
             // FIXME: Support the byUser argument.
             fire.async(notificationId, true);
           };
 
           notificationsMap.get(extension).on("closed", listener);
           return () => {
             notificationsMap.get(extension).off("closed", listener);
           };
         }).api(),
 
-        onClicked: new SingletonEventManager(context, "notifications.onClicked", fire => {
+        onClicked: new EventManager(context, "notifications.onClicked", fire => {
           let listener = (event, notificationId) => {
             fire.async(notificationId, true);
           };
 
           notificationsMap.get(extension).on("clicked", listener);
           return () => {
             notificationsMap.get(extension).off("clicked", listener);
           };

--- a/toolkit/components/extensions/ext-proxy.js
+++ b/toolkit/components/extensions/ext-proxy.js
@@ -39,17 +39,17 @@ this.proxy = class extends ExtensionAPI 
           }
 
           let proxyScriptContext = new ProxyScriptContext(extension, url);
           if (proxyScriptContext.load()) {
             proxyScriptContextMap.set(extension, proxyScriptContext);
           }
         },
 
-        onProxyError: new SingletonEventManager(context, "proxy.onProxyError", fire => {
+        onProxyError: new EventManager(context, "proxy.onProxyError", fire => {
           let listener = (name, error) => {
             fire.async(error);
           };
           extension.on("proxy-error", listener);
           return () => {
             extension.off("proxy-error", listener);
           };
         }).api(),

--- a/toolkit/components/extensions/ext-runtime.js
+++ b/toolkit/components/extensions/ext-runtime.js
@@ -14,33 +14,33 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
                                   "resource://gre/modules/NetUtil.jsm");
 
 this.runtime = class extends ExtensionAPI {
   getAPI(context) {
     let {extension} = context;
     return {
       runtime: {
-        onStartup: new SingletonEventManager(context, "runtime.onStartup", fire => {
+        onStartup: new EventManager(context, "runtime.onStartup", fire => {
           if (context.incognito) {
             // This event should not fire if we are operating in a private profile.
             return () => {};
           }
           let listener = () => {
             if (extension.startupReason === "APP_STARTUP") {
               fire.sync();
             }
           };
           extension.on("startup", listener);
           return () => {
             extension.off("startup", listener);
           };
         }).api(),
 
-        onInstalled: new SingletonEventManager(context, "runtime.onInstalled", fire => {
+        onInstalled: new EventManager(context, "runtime.onInstalled", fire => {
           let temporary = !!extension.addonData.temporarilyInstalled;
 
           let listener = () => {
             switch (extension.startupReason) {
               case "APP_STARTUP":
                 if (AddonManagerPrivate.browserUpdated) {
                   fire.sync({reason: "browser_update", temporary});
                 }
@@ -58,17 +58,17 @@ this.runtime = class extends ExtensionAP
             }
           };
           extension.on("startup", listener);
           return () => {
             extension.off("startup", listener);
           };
         }).api(),
 
-        onUpdateAvailable: new SingletonEventManager(context, "runtime.onUpdateAvailable", fire => {
+        onUpdateAvailable: new EventManager(context, "runtime.onUpdateAvailable", fire => {
           let instanceID = extension.addonData.instanceID;
           AddonManager.addUpgradeListener(instanceID, upgrade => {
             extension.upgrade = upgrade;
             let details = {
               version: upgrade.version,
             };
             fire.sync(details);
           });

--- a/toolkit/components/extensions/ext-storage.js
+++ b/toolkit/components/extensions/ext-storage.js
@@ -58,17 +58,17 @@ this.storage = class extends ExtensionAP
             return extensionStorageSync.remove(extension, keys, context);
           },
           clear: function() {
             enforceNoTemporaryAddon(extension.id);
             return extensionStorageSync.clear(extension, context);
           },
         },
 
-        onChanged: new SingletonEventManager(context, "storage.onChanged", fire => {
+        onChanged: new EventManager(context, "storage.onChanged", fire => {
           let listenerLocal = changes => {
             fire.async(changes, "local");
           };
           let listenerSync = changes => {
             fire.async(changes, "sync");
           };
 
           ExtensionStorage.addOnChangedListener(extension.id, listenerLocal);

--- a/toolkit/components/extensions/ext-toolkit.js
+++ b/toolkit/components/extensions/ext-toolkit.js
@@ -1,28 +1,28 @@
 "use strict";
 
 // These are defined on "global" which is used for the same scopes as the other
 // ext-*.js files.
 /* exported getCookieStoreIdForTab, getCookieStoreIdForContainer,
             getContainerForCookieStoreId,
             isValidCookieStoreId, isContainerCookieStoreId,
-            SingletonEventManager */
+            EventManager */
 /* global getCookieStoreIdForTab:false, getCookieStoreIdForContainer:false,
           getContainerForCookieStoreId: false,
           isValidCookieStoreId:false, isContainerCookieStoreId:false,
           isDefaultCookieStoreId: false, isPrivateCookieStoreId:false,
-          SingletonEventManager: false */
+          EventManager: false */
 
 XPCOMUtils.defineLazyModuleGetter(this, "ContextualIdentityService",
                                   "resource://gre/modules/ContextualIdentityService.jsm");
 
 Cu.import("resource://gre/modules/ExtensionCommon.jsm");
 
-global.SingletonEventManager = ExtensionCommon.SingletonEventManager;
+global.EventManager = ExtensionCommon.EventManager;
 
 /* globals DEFAULT_STORE, PRIVATE_STORE, CONTAINER_STORE */
 
 global.DEFAULT_STORE = "firefox-default";
 global.PRIVATE_STORE = "firefox-private";
 global.CONTAINER_STORE = "firefox-container-";
 
 global.getCookieStoreIdForTab = function(data, tab) {

--- a/toolkit/components/extensions/ext-webNavigation.js
+++ b/toolkit/components/extensions/ext-webNavigation.js
@@ -139,20 +139,20 @@ function WebNavigationEventManager(conte
     };
 
     WebNavigation[eventName].addListener(listener, filters);
     return () => {
       WebNavigation[eventName].removeListener(listener);
     };
   };
 
-  return SingletonEventManager.call(this, context, name, register);
+  return EventManager.call(this, context, name, register);
 }
 
-WebNavigationEventManager.prototype = Object.create(SingletonEventManager.prototype);
+WebNavigationEventManager.prototype = Object.create(EventManager.prototype);
 
 function convertGetFrameResult(tabId, data) {
   return {
     errorOccurred: data.errorOccurred,
     url: data.url,
     tabId,
     frameId: data.frameId,
     parentFrameId: data.parentFrameId,
@@ -160,17 +160,17 @@ function convertGetFrameResult(tabId, da
 }
 
 this.webNavigation = class extends ExtensionAPI {
   getAPI(context) {
     let {tabManager} = context.extension;
 
     return {
       webNavigation: {
-        onTabReplaced: new SingletonEventManager(context, "webNavigation.onTabReplaced", fire => {
+        onTabReplaced: new EventManager(context, "webNavigation.onTabReplaced", fire => {
           return () => {};
         }).api(),
         onBeforeNavigate: new WebNavigationEventManager(context, "onBeforeNavigate").api(),
         onCommitted: new WebNavigationEventManager(context, "onCommitted").api(),
         onDOMContentLoaded: new WebNavigationEventManager(context, "onDOMContentLoaded").api(),
         onCompleted: new WebNavigationEventManager(context, "onCompleted").api(),
         onErrorOccurred: new WebNavigationEventManager(context, "onErrorOccurred").api(),
         onReferenceFragmentUpdated: new WebNavigationEventManager(context, "onReferenceFragmentUpdated").api(),

--- a/toolkit/components/extensions/ext-webRequest.js
+++ b/toolkit/components/extensions/ext-webRequest.js
@@ -6,17 +6,17 @@
 // This file expectes tabTracker to be defined in the global scope (e.g.
 // by ext-utils.js).
 /* global tabTracker */
 
 XPCOMUtils.defineLazyModuleGetter(this, "WebRequest",
                                   "resource://gre/modules/WebRequest.jsm");
 
 // EventManager-like class specifically for WebRequest. Inherits from
-// SingletonEventManager. Takes care of converting |details| parameter
+// EventManager. Takes care of converting |details| parameter
 // when invoking listeners.
 function WebRequestEventManager(context, eventName) {
   let name = `webRequest.${eventName}`;
   let register = (fire, filter, info) => {
     let listener = data => {
       // Prevent listening in on requests originating from system principal to
       // prevent tinkering with OCSP, app and addon updates, etc.
       if (data.isSystemPrincipal) {
@@ -113,20 +113,20 @@ function WebRequestEventManager(context,
     }
 
     WebRequest[eventName].addListener(listener, filter2, info2);
     return () => {
       WebRequest[eventName].removeListener(listener);
     };
   };
 
-  return SingletonEventManager.call(this, context, name, register);
+  return EventManager.call(this, context, name, register);
 }
 
-WebRequestEventManager.prototype = Object.create(SingletonEventManager.prototype);
+WebRequestEventManager.prototype = Object.create(EventManager.prototype);
 
 this.webRequest = class extends ExtensionAPI {
   getAPI(context) {
     return {
       webRequest: {
         onBeforeRequest: new WebRequestEventManager(context, "onBeforeRequest").api(),
         onBeforeSendHeaders: new WebRequestEventManager(context, "onBeforeSendHeaders").api(),
         onSendHeaders: new WebRequestEventManager(context, "onSendHeaders").api(),

--- a/toolkit/components/extensions/test/xpcshell/test_ext_contexts.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_contexts.js
@@ -3,17 +3,17 @@
 const global = this;
 
 Cu.import("resource://gre/modules/Timer.jsm");
 
 Cu.import("resource://gre/modules/ExtensionCommon.jsm");
 
 var {
   BaseContext,
-  SingletonEventManager,
+  EventManager,
 } = ExtensionCommon;
 
 class StubContext extends BaseContext {
   constructor() {
     let fakeExtension = {id: "test@web.extension"};
     super("testEnv", fakeExtension);
     this.sandbox = Cu.Sandbox(global);
   }
@@ -55,56 +55,56 @@ add_task(async function test_post_unload
   // any micro-tasks that get enqueued by the resolution handlers above.
   await new Promise(resolve => setTimeout(resolve, 0));
 });
 
 
 add_task(async function test_post_unload_listeners() {
   let context = new StubContext();
 
-  let fireSingleton;
-  let onSingleton = new SingletonEventManager(context, "onSingleton", fire => {
-    fireSingleton = () => {
-      fire.async();
+  let fire;
+  let manager = new EventManager(context, "EventManager", _fire => {
+    fire = () => {
+      _fire.async();
     };
     return () => {};
   });
 
   let fail = event => {
     ok(false, `Unexpected event: ${event}`);
   };
 
   // Check that event listeners isn't called after it has been removed.
-  onSingleton.addListener(fail);
+  manager.addListener(fail);
 
-  let promise = new Promise(resolve => onSingleton.addListener(resolve));
+  let promise = new Promise(resolve => manager.addListener(resolve));
 
-  fireSingleton("onSingleton");
+  fire();
 
   // The `fireSingleton` call ia dispatched asynchronously, so it won't
   // have fired by this point. The `fail` listener that we remove now
   // should not be called, even though the event has already been
   // enqueued.
-  onSingleton.removeListener(fail);
+  manager.removeListener(fail);
 
   // Wait for the remaining listener to be called, which should always
   // happen after the `fail` listener would normally be called.
   await promise;
 
   // Check that the event listener isn't called after the context has
   // unloaded.
-  onSingleton.addListener(fail);
+  manager.addListener(fail);
 
   // The `fire` callback always dispatches events
   // asynchronously, so we need to test that any pending event callbacks
   // aren't fired after the context unloads. We also need to test that
   // any `fire` calls that happen *after* the context is unloaded also
   // do not trigger callbacks.
-  fireSingleton("onSingleton");
-  Promise.resolve("onSingleton").then(fireSingleton);
+  fire();
+  Promise.resolve().then(fire);
 
   context.unload();
 
   // The `setTimeout` ensures that we return to the event loop after
   // promise resolution, which means we're guaranteed to return after
   // any micro-tasks that get enqueued by the resolution handlers above.
   await new Promise(resolve => setTimeout(resolve, 0));
 });