--- a/devtools/server/main.js
+++ b/devtools/server/main.js
@@ -15,17 +15,17 @@ var Services = require("Services");
 var { ActorPool, OriginalLocation, RegisteredActorFactory,
       ObservedActorFactory } = require("devtools/server/actors/common");
 var { LocalDebuggerTransport, ChildDebuggerTransport, WorkerDebuggerTransport } =
   require("devtools/shared/transport/transport");
 var DevToolsUtils = require("devtools/shared/DevToolsUtils");
 var { dumpn, dumpv } = DevToolsUtils;
 var EventEmitter = require("devtools/shared/event-emitter");
 var Debugger = require("Debugger");
-var Promise = require("promise");
+var promise = require("promise");
 
 DevToolsUtils.defineLazyGetter(this, "DebuggerSocket", () => {
   let { DebuggerSocket } = require("devtools/shared/security/socket");
   return DebuggerSocket;
 });
 DevToolsUtils.defineLazyGetter(this, "Authentication", () => {
   return require("devtools/shared/security/auth");
 });
@@ -82,22 +82,16 @@ function loadSubScript(aURL)
     dump(errorStr);
     reportError(errorStr);
     throw e;
   }
 }
 
 loader.lazyRequireGetter(this, "events", "sdk/event/core");
 
-var {defer, resolve, reject, all} = require("devtools/shared/deprecated-sync-thenables");
-this.defer = defer;
-this.resolve = resolve;
-this.reject = reject;
-this.all = all;
-
 var gRegisteredModules = Object.create(null);
 
 /**
  * The ModuleAPI object is passed to modules loaded using the
  * DebuggerServer.registerModule() API.  Modules can use this
  * object to register actor factories.
  * Factories registered through the module API will be removed
  * when the module is unregistered or when the server is
@@ -585,17 +579,17 @@ var DebuggerServer = {
 
     let promises = [];
 
     // Pass to all connections
     for (let connID of Object.getOwnPropertyNames(this._connections)) {
       promises.push(this._connections[connID].setAddonOptions(aId, aOptions));
     }
 
-    return all(promises);
+    return promise.all(promises);
   },
 
   get listeningSockets() {
     return this._listeners.length;
   },
 
   /**
    * Creates a socket listener for remote debugger connections.
@@ -709,17 +703,17 @@ var DebuggerServer = {
     let transport = isWorker ?
                     new WorkerDebuggerTransport(aScopeOrManager, aPrefix) :
                     new ChildDebuggerTransport(aScopeOrManager, aPrefix);
 
     return this._onConnection(transport, aPrefix, true);
   },
 
   connectToContent: function (aConnection, aMm) {
-    let deferred = defer();
+    let deferred = promise.defer();
 
     let prefix = aConnection.allocID("content-process");
     let actor, childTransport;
 
     aMm.addMessageListener("debug:content-process-actor", function listener(msg) {
       // Arbitrarily choose the first content process to reply
       // XXX: This code needs to be updated if we use more than one content process
       aMm.removeMessageListener("debug:content-process-actor", listener);
@@ -772,17 +766,17 @@ var DebuggerServer = {
                              "message-manager-close", false);
 
     events.on(aConnection, "closed", onClose);
 
     return deferred.promise;
   },
 
   connectToWorker: function (aConnection, aDbg, aId, aOptions) {
-    return new Promise((resolve, reject) => {
+    return new promise((resolve, reject) => {
       // Step 1: Ensure the worker debugger is initialized.
       if (!aDbg.isInitialized) {
         aDbg.initialize("resource://devtools/server/worker.js");
 
         // Create a listener for rpc requests from the worker debugger. Only do
         // this once, when the worker debugger is first initialized, rather than
         // for each connection.
         let listener = {
@@ -791,17 +785,17 @@ var DebuggerServer = {
           },
 
           onMessage: (message) => {
             let packet = JSON.parse(message);
             if (packet.type !== "rpc") {
               return;
             }
 
-            Promise.resolve().then(() => {
+            promise.resolve().then(() => {
               let method = {
                 "fetch": DevToolsUtils.fetch,
               }[packet.method];
               if (!method) {
                 throw Error("Unknown method: " + packet.method);
               }
 
               return method.apply(undefined, packet.params);
@@ -911,19 +905,19 @@ var DebuggerServer = {
    *        The name of the setup helper exported by the above module
    *        (setup helper signature: function ({mm}) { ... })
    * @param waitForEval (optional)
    *        If true, the returned promise only resolves once code in child
    *        is evaluated
    */
   setupInChild: function({ module, setupChild, args, waitForEval }) {
     if (this.isInChildProcess || this._childMessageManagers.size == 0) {
-      return Promise.resolve();
+      return promise.resolve();
     }
-    let deferred = Promise.defer();
+    let deferred = promise.defer();
 
     // If waitForEval is set, pass a unique id and expect child.js to send
     // a message back once the code in child is evaluated.
     if (typeof(waitForEval) != "boolean") {
       waitForEval = false;
     }
     let count = this._childMessageManagers.size;
     let id = waitForEval ? generateUUID().toString() : null;
@@ -948,17 +942,17 @@ var DebuggerServer = {
         args: args,
         id: id,
       });
     });
 
     if (waitForEval) {
       return deferred.promise;
     } else {
-      return Promise.resolve();
+      return promise.resolve();
     }
   },
 
   /**
    * Live list of all currenctly attached child's message managers.
    */
   _childMessageManagers: new Set(),
 
@@ -973,17 +967,17 @@ var DebuggerServer = {
    *        Optional function to invoke when the child process closes
    *        or the connection shuts down. (Need to forget about the
    *        related TabActor)
    * @return object
    *         A promise object that is resolved once the connection is
    *         established.
    */
   connectToChild: function(aConnection, aFrame, aOnDestroy) {
-    let deferred = defer();
+    let deferred = promise.defer();
 
     let mm = aFrame.QueryInterface(Ci.nsIFrameLoaderOwner).frameLoader
              .messageManager;
     mm.loadFrameScript("resource://devtools/server/child.js", false);
     this._childMessageManagers.add(mm);
 
     let actor, childTransport;
     let prefix = aConnection.allocID("child");
@@ -1513,17 +1507,17 @@ DebuggerServerConnection.prototype = {
     dumpn(errorString);
     return {
       error: "unknownError",
       message: errorString
     };
   },
 
   _queueResponse: function(from, type, response) {
-    let pendingResponse = this._actorResponses.get(from) || resolve(null);
+    let pendingResponse = this._actorResponses.get(from) || promise.resolve(null);
     let responsePromise = pendingResponse.then(() => {
       return response;
     }).then(aResponse => {
       if (!aResponse.from) {
         aResponse.from = from;
       }
       this.transport.send(aResponse);
     }).then(null, (e) => {
@@ -1544,17 +1538,17 @@ DebuggerServerConnection.prototype = {
    *        The ID of the add-on to pass the options to
    * @param aOptions object
    *        The options.
    * @return a promise that will be resolved when complete.
    */
   setAddonOptions: function DSC_setAddonOptions(aId, aOptions) {
     let addonList = this.rootActor._parameters.addonList;
     if (!addonList) {
-      return resolve();
+      return promise.resolve();
     }
     return addonList.getList().then((addonActors) => {
       for (let actor of addonActors) {
         if (actor.id != aId) {
           continue;
         }
         actor.setOptions(aOptions);
         return;