--- a/toolkit/modules/EventEmitter.jsm
+++ b/toolkit/modules/EventEmitter.jsm
@@ -40,18 +40,16 @@
     this.isWorker = false;
     const Cu = Components.utils;
     let console = Cu.import("resource://gre/modules/Console.jsm", {}).console;
     // Bug 1259045: This module is loaded early in firefox startup as a JSM,
     // but it doesn't depends on any real module. We can save a few cycles
     // and bytes by not loading Loader.jsm.
     let require = function(module) {
       switch (module) {
-        case "devtools/shared/defer":
-          return Cu.import("resource://gre/modules/Promise.jsm", {}).Promise.defer;
         case "Services":
           return Cu.import("resource://gre/modules/Services.jsm", {}).Services;
         case "devtools/shared/platform/stack": {
           let obj = {};
           Cu.import("resource://devtools/shared/platform/chrome/stack.js", obj);
           return obj;
         }
       }
@@ -64,17 +62,16 @@
   // ⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠⚠
   // After this point the code may not use Cu.import, and should only
   // require() modules that are "clean-for-content".
   let EventEmitter = this.EventEmitter = function() {};
   module.exports = EventEmitter;
 
   // See comment in JSM module boilerplate when adding a new dependency.
   const Services = require("Services");
-  const defer = require("devtools/shared/defer");
   let loggingEnabled = true;
 
   if (!isWorker) {
     loggingEnabled = Services.prefs.getBoolPref("devtools.dump.emit");
     Services.prefs.addObserver("devtools.dump.emit", {
       observe: () => {
         loggingEnabled = Services.prefs.getBoolPref("devtools.dump.emit");
       }
@@ -143,30 +140,28 @@
      *        one time.
      * @return promise
      *        A promise which is resolved when the event next happens. The
      *        resolution value of the promise is the first event argument. If
      *        you need access to second or subsequent event arguments (it's rare
      *        that this is needed) then use listener
      */
     once(event, listener) {
-      let deferred = defer();
+      return new Promise(resolve => {
+        let handler = (_, first, ...rest) => {
+          this.off(event, handler);
+          if (listener) {
+            listener(event, first, ...rest);
+          }
+          resolve(first);
+        };
 
-      let handler = (_, first, ...rest) => {
-        this.off(event, handler);
-        if (listener) {
-          listener(event, first, ...rest);
-        }
-        deferred.resolve(first);
-      };
-
-      handler._originalListener = listener;
-      this.on(event, handler);
-
-      return deferred.promise;
+        handler._originalListener = listener;
+        this.on(event, handler);
+      });
     },
 
     /**
      * Remove a previously-registered event listener.  Works for events
      * registered with either on or once.
      *
      * @param string event
      *        The event name whose listener we're disconnecting.