Add m-esr52 at 52.6.0

11 files changed, 2132 insertions, 0 deletions

diff --git a/toolkit/components/asyncshutdown/AsyncShutdown.jsm b/toolkit/components/asyncshutdown/AsyncShutdown.jsm
new file mode 100644
index 000000000..62ac36f42
--- /dev/null
+++ b/toolkit/components/asyncshutdown/AsyncShutdown.jsm
@@ -0,0 +1,1041 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Managing safe shutdown of asynchronous services.
+ *
+ * Firefox shutdown is composed of phases that take place
+ * sequentially. Typically, each shutdown phase removes some
+ * capabilities from the application. For instance, at the end of
+ * phase profileBeforeChange, no service is permitted to write to the
+ * profile directory (with the exception of Telemetry). Consequently,
+ * if any service has requested I/O to the profile directory before or
+ * during phase profileBeforeChange, the system must be informed that
+ * these requests need to be completed before the end of phase
+ * profileBeforeChange. Failing to inform the system of this
+ * requirement can (and has been known to) cause data loss.
+ *
+ * Example: At some point during shutdown, the Add-On Manager needs to
+ * ensure that all add-ons have safely written their data to disk,
+ * before writing its own data. Since the data is saved to the
+ * profile, this must be completed during phase profileBeforeChange.
+ *
+ * AsyncShutdown.profileBeforeChange.addBlocker(
+ *   "Add-on manager: shutting down",
+ *   function condition() {
+ *     // Do things.
+ *     // Perform I/O that must take place during phase profile-before-change
+ *     return promise;
+ *   }
+ * });
+ *
+ * In this example, function |condition| will be called at some point
+ * during phase profileBeforeChange and phase profileBeforeChange
+ * itself is guaranteed to not terminate until |promise| is either
+ * resolved or rejected.
+ */
+
+"use strict";
+
+const Cu = Components.utils;
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
+Cu.import("resource://gre/modules/Services.jsm", this);
+
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PromiseUtils",
+  "resource://gre/modules/PromiseUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+  "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyServiceGetter(this, "gDebug",
+  "@mozilla.org/xpcom/debug;1", "nsIDebug2");
+Object.defineProperty(this, "gCrashReporter", {
+  get: function() {
+    delete this.gCrashReporter;
+    try {
+      let reporter = Cc["@mozilla.org/xre/app-info;1"].
+            getService(Ci.nsICrashReporter);
+      return this.gCrashReporter = reporter;
+    } catch (ex) {
+      return this.gCrashReporter = null;
+    }
+  },
+  configurable: true
+});
+
+// `true` if this is a content process, `false` otherwise.
+// It would be nicer to go through `Services.appInfo`, but some tests need to be
+// able to replace that field with a custom implementation before it is first
+// called.
+const isContent = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT;
+
+// Display timeout warnings after 10 seconds
+const DELAY_WARNING_MS = 10 * 1000;
+
+
+// Crash the process if shutdown is really too long
+// (allowing for sleep).
+const PREF_DELAY_CRASH_MS = "toolkit.asyncshutdown.crash_timeout";
+var DELAY_CRASH_MS = 60 * 1000; // One minute
+try {
+  DELAY_CRASH_MS = Services.prefs.getIntPref(PREF_DELAY_CRASH_MS);
+} catch (ex) {
+  // Ignore errors
+}
+Services.prefs.addObserver(PREF_DELAY_CRASH_MS, function() {
+  DELAY_CRASH_MS = Services.prefs.getIntPref(PREF_DELAY_CRASH_MS);
+}, false);
+
+/**
+ * A set of Promise that supports waiting.
+ *
+ * Promise items may be added or removed during the wait. The wait will
+ * resolve once all Promise items have been resolved or removed.
+ */
+function PromiseSet() {
+  /**
+   * key: the Promise passed pass the client of the `PromiseSet`.
+   * value: an indirection on top of `key`, as an object with
+   *   the following fields:
+   *   - indirection: a Promise resolved if `key` is resolved or
+   *     if `resolve` is called
+   *   - resolve: a function used to resolve the indirection.
+   */
+  this._indirections = new Map();
+}
+PromiseSet.prototype = {
+  /**
+   * Wait until all Promise have been resolved or removed.
+   *
+   * Note that calling `wait()` causes Promise to be removed from the
+   * Set once they are resolved.
+   *
+   * @return {Promise} Resolved once all Promise have been resolved or removed,
+   * or rejected after at least one Promise has rejected.
+   */
+  wait: function() {
+    // Pick an arbitrary element in the map, if any exists.
+    let entry = this._indirections.entries().next();
+    if (entry.done) {
+      // No indirections left, we are done.
+      return Promise.resolve();
+    }
+
+    let [, indirection] = entry.value;
+    let promise = indirection.promise;
+    promise = promise.then(() =>
+      // At this stage, the entry has been cleaned up.
+      this.wait()
+    );
+    return promise;
+  },
+
+  /**
+   * Add a new Promise to the set.
+   *
+   * Calls to wait (including ongoing calls) will only return once
+   * `key` has either resolved or been removed.
+   */
+  add: function(key) {
+    this._ensurePromise(key);
+    let indirection = PromiseUtils.defer();
+    key.then(
+      x => {
+        // Clean up immediately.
+        // This needs to be done before the call to `resolve`, otherwise
+        // `wait()` may loop forever.
+        this._indirections.delete(key);
+        indirection.resolve(x);
+      },
+      err => {
+        this._indirections.delete(key);
+        indirection.reject(err);
+      });
+    this._indirections.set(key, indirection);
+  },
+
+  /**
+   * Remove a Promise from the set.
+   *
+   * Calls to wait (including ongoing calls) will ignore this promise,
+   * unless it is added again.
+   */
+  delete: function(key) {
+    this._ensurePromise(key);
+    let value = this._indirections.get(key);
+    if (!value) {
+      return false;
+    }
+    this._indirections.delete(key);
+    value.resolve();
+    return true;
+  },
+
+  _ensurePromise: function(key) {
+    if (!key || typeof key != "object") {
+      throw new Error("Expected an object");
+    }
+    if ((!("then" in key)) || typeof key.then != "function") {
+      throw new Error("Expected a Promise");
+    }
+  },
+
+};
+
+
+/**
+ * Display a warning.
+ *
+ * As this code is generally used during shutdown, there are chances
+ * that the UX will not be available to display warnings on the
+ * console. We therefore use dump() rather than Cu.reportError().
+ */
+function log(msg, prefix = "", error = null) {
+  try {
+    dump(prefix + msg + "\n");
+    if (error) {
+      dump(prefix + error + "\n");
+      if (typeof error == "object" && "stack" in error) {
+        dump(prefix + error.stack + "\n");
+      }
+    }
+  } catch (ex) {
+    dump("INTERNAL ERROR in AsyncShutdown: cannot log message.\n");
+  }
+}
+const PREF_DEBUG_LOG = "toolkit.asyncshutdown.log";
+var DEBUG_LOG = false;
+try {
+  DEBUG_LOG = Services.prefs.getBoolPref(PREF_DEBUG_LOG);
+} catch (ex) {
+  // Ignore errors
+}
+Services.prefs.addObserver(PREF_DEBUG_LOG, function() {
+  DEBUG_LOG = Services.prefs.getBoolPref(PREF_DEBUG_LOG);
+}, false);
+
+function debug(msg, error=null) {
+  if (DEBUG_LOG) {
+    log(msg, "DEBUG: ", error);
+  }
+}
+function warn(msg, error = null) {
+  log(msg, "WARNING: ", error);
+}
+function fatalerr(msg, error = null) {
+  log(msg, "FATAL ERROR: ", error);
+}
+
+// Utility function designed to get the current state of execution
+// of a blocker.
+// We are a little paranoid here to ensure that in case of evaluation
+// error we do not block the AsyncShutdown.
+function safeGetState(fetchState) {
+  if (!fetchState) {
+    return "(none)";
+  }
+  let data, string;
+  try {
+    // Evaluate fetchState(), normalize the result into something that we can
+    // safely stringify or upload.
+    let state = fetchState();
+    if (!state) {
+      return "(none)";
+    }
+    string = JSON.stringify(state);
+    data = JSON.parse(string);
+    // Simplify the rest of the code by ensuring that we can simply
+    // concatenate the result to a message.
+    if (data && typeof data == "object") {
+      data.toString = function() {
+        return string;
+      };
+    }
+    return data;
+  } catch (ex) {
+
+    // Make sure that this causes test failures
+    Promise.reject(ex);
+
+    if (string) {
+      return string;
+    }
+    try {
+      return "Error getting state: " + ex + " at " + ex.stack;
+    } catch (ex2) {
+      return "Error getting state but could not display error";
+    }
+  }
+}
+
+/**
+ * Countdown for a given duration, skipping beats if the computer is too busy,
+ * sleeping or otherwise unavailable.
+ *
+ * @param {number} delay An approximate delay to wait in milliseconds (rounded
+ * up to the closest second).
+ *
+ * @return Deferred
+ */
+function looseTimer(delay) {
+  let DELAY_BEAT = 1000;
+  let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+  let beats = Math.ceil(delay / DELAY_BEAT);
+  let deferred = Promise.defer();
+  timer.initWithCallback(function() {
+    if (beats <= 0) {
+      deferred.resolve();
+    }
+    --beats;
+  }, DELAY_BEAT, Ci.nsITimer.TYPE_REPEATING_PRECISE_CAN_SKIP);
+  // Ensure that the timer is both canceled once we are done with it
+  // and not garbage-collected until then.
+  deferred.promise.then(() => timer.cancel(), () => timer.cancel());
+  return deferred;
+}
+
+/**
+ * Given an nsIStackFrame object, find the caller filename, line number,
+ * and stack if necessary, and return them as an object.
+ *
+ * @param {nsIStackFrame} topFrame Top frame of the call stack.
+ * @param {string} filename Pre-supplied filename or null if unknown.
+ * @param {number} lineNumber Pre-supplied line number or null if unknown.
+ * @param {string} stack Pre-supplied stack or null if unknown.
+ *
+ * @return object
+ */
+function getOrigin(topFrame, filename = null, lineNumber = null, stack = null) {
+  try {
+    // Determine the filename and line number of the caller.
+    let frame = topFrame;
+
+    for (; frame && frame.filename == topFrame.filename; frame = frame.caller) {
+      // Climb up the stack
+    }
+
+    if (filename == null) {
+      filename = frame ? frame.filename : "?";
+    }
+    if (lineNumber == null) {
+      lineNumber = frame ? frame.lineNumber : 0;
+    }
+    if (stack == null) {
+      // Now build the rest of the stack as a string, using Task.jsm's rewriting
+      // to ensure that we do not lose information at each call to `Task.spawn`.
+      let frames = [];
+      while (frame != null) {
+        frames.push(frame.filename + ":" + frame.name + ":" + frame.lineNumber);
+        frame = frame.caller;
+      }
+      stack = Task.Debugging.generateReadableStack(frames.join("\n")).split("\n");
+    }
+
+    return {
+      filename: filename,
+      lineNumber: lineNumber,
+      stack: stack,
+    };
+  } catch (ex) {
+    return {
+      filename: "<internal error: could not get origin>",
+      lineNumber: -1,
+      stack: "<internal error: could not get origin>",
+    }
+  }
+}
+
+this.EXPORTED_SYMBOLS = ["AsyncShutdown"];
+
+/**
+ * {string} topic -> phase
+ */
+var gPhases = new Map();
+
+this.AsyncShutdown = {
+  /**
+   * Access function getPhase. For testing purposes only.
+   */
+  get _getPhase() {
+    let accepted = false;
+    try {
+      accepted = Services.prefs.getBoolPref("toolkit.asyncshutdown.testing");
+    } catch (ex) {
+      // Ignore errors
+    }
+    if (accepted) {
+      return getPhase;
+    }
+    return undefined;
+  }
+};
+
+/**
+ * Register a new phase.
+ *
+ * @param {string} topic The notification topic for this Phase.
+ * @see {https://developer.mozilla.org/en-US/docs/Observer_Notifications}
+ */
+function getPhase(topic) {
+  let phase = gPhases.get(topic);
+  if (phase) {
+    return phase;
+  }
+  let spinner = new Spinner(topic);
+  phase = Object.freeze({
+    /**
+     * Register a blocker for the completion of a phase.
+     *
+     * @param {string} name The human-readable name of the blocker. Used
+     * for debugging/error reporting. Please make sure that the name
+     * respects the following model: "Some Service: some action in progress" -
+     * for instance "OS.File: flushing all pending I/O";
+     * @param {function|promise|*} condition A condition blocking the
+     * completion of the phase. Generally, this is a function
+     * returning a promise. This function is evaluated during the
+     * phase and the phase is guaranteed to not terminate until the
+     * resulting promise is either resolved or rejected. If
+     * |condition| is not a function but another value |v|, it behaves
+     * as if it were a function returning |v|.
+     * @param {object*} details Optionally, an object with details
+     * that may be useful for error reporting, as a subset of of the following
+     * fields:
+     * - fetchState (strongly recommended) A function returning
+     *    information about the current state of the blocker as an
+     *    object. Used for providing more details when logging errors or
+     *    crashing.
+     * - stack. A string containing stack information. This module can
+     *    generally infer stack information if it is not provided.
+     * - lineNumber A number containing the line number for the caller.
+     *    This module can generally infer this information if it is not
+     *    provided.
+     * - filename A string containing the filename for the caller. This
+     *    module can generally infer  the information if it is not provided.
+     *
+     * Examples:
+     * AsyncShutdown.profileBeforeChange.addBlocker("Module: just a promise",
+     *      promise); // profileBeforeChange will not complete until
+     *                // promise is resolved or rejected
+     *
+     * AsyncShutdown.profileBeforeChange.addBlocker("Module: a callback",
+     *     function callback() {
+     *       // ...
+     *       // Execute this code during profileBeforeChange
+     *       return promise;
+     *       // profileBeforeChange will not complete until promise
+     *       // is resolved or rejected
+     * });
+     *
+     * AsyncShutdown.profileBeforeChange.addBlocker("Module: trivial callback",
+     *     function callback() {
+     *       // ...
+     *       // Execute this code during profileBeforeChange
+     *       // No specific guarantee about completion of profileBeforeChange
+     * });
+     */
+    addBlocker: function(name, condition, details = null) {
+      spinner.addBlocker(name, condition, details);
+    },
+    /**
+     * Remove the blocker for a condition.
+     *
+     * If several blockers have been registered for the same
+     * condition, remove all these blockers. If no blocker has been
+     * registered for this condition, this is a noop.
+     *
+     * @return {boolean} true if a blocker has been removed, false
+     * otherwise. Note that a result of false may mean either that
+     * the blocker has never been installed or that the phase has
+     * completed and the blocker has already been resolved.
+     */
+    removeBlocker: function(condition) {
+      return spinner.removeBlocker(condition);
+    },
+
+    get name() {
+      return spinner.name;
+    },
+
+    /**
+     * Trigger the phase without having to broadcast a
+     * notification. For testing purposes only.
+     */
+    get _trigger() {
+      let accepted = false;
+      try {
+        accepted = Services.prefs.getBoolPref("toolkit.asyncshutdown.testing");
+      } catch (ex) {
+        // Ignore errors
+      }
+      if (accepted) {
+        return () => spinner.observe();
+      }
+      return undefined;
+    }
+  });
+  gPhases.set(topic, phase);
+  return phase;
+}
+
+/**
+ * Utility class used to spin the event loop until all blockers for a
+ * Phase are satisfied.
+ *
+ * @param {string} topic The xpcom notification for that phase.
+ */
+function Spinner(topic) {
+  this._barrier = new Barrier(topic);
+  this._topic = topic;
+  Services.obs.addObserver(this, topic, false);
+}
+
+Spinner.prototype = {
+  /**
+   * Register a new condition for this phase.
+   *
+   * See the documentation of `addBlocker` in property `client`
+   * of instances of `Barrier`.
+   */
+  addBlocker: function(name, condition, details) {
+    this._barrier.client.addBlocker(name, condition, details);
+  },
+  /**
+   * Remove the blocker for a condition.
+   *
+   * See the documentation of `removeBlocker` in rpoperty `client`
+   * of instances of `Barrier`
+   *
+   * @return {boolean} true if a blocker has been removed, false
+   * otherwise. Note that a result of false may mean either that
+   * the blocker has never been installed or that the phase has
+   * completed and the blocker has already been resolved.
+   */
+  removeBlocker: function(condition) {
+    return this._barrier.client.removeBlocker(condition);
+  },
+
+  get name() {
+    return this._barrier.client.name;
+  },
+
+  // nsIObserver.observe
+  observe: function() {
+    let topic = this._topic;
+    debug(`Starting phase ${ topic }`);
+    Services.obs.removeObserver(this, topic);
+
+    let satisfied = false; // |true| once we have satisfied all conditions
+    let promise;
+    try {
+      promise = this._barrier.wait({
+        warnAfterMS: DELAY_WARNING_MS,
+        crashAfterMS: DELAY_CRASH_MS
+      }).catch(
+        // Additional precaution to be entirely sure that we cannot reject.
+      );
+    } catch (ex) {
+      debug("Error waiting for notification");
+      throw ex;
+    }
+
+    // Now, spin the event loop
+    debug("Spinning the event loop");
+    promise.then(() => satisfied = true); // This promise cannot reject
+    let thread = Services.tm.mainThread;
+    while (!satisfied) {
+      try {
+        thread.processNextEvent(true);
+      } catch (ex) {
+        // An uncaught error should not stop us, but it should still
+        // be reported and cause tests to fail.
+        Promise.reject(ex);
+      }
+    }
+    debug(`Finished phase ${ topic }`);
+  }
+};
+
+/**
+ * A mechanism used to register blockers that prevent some action from
+ * happening.
+ *
+ * An instance of |Barrier| provides a capability |client| that
+ * clients can use to register blockers. The barrier is resolved once
+ * all registered blockers have been resolved. The owner of the
+ * |Barrier| may wait for the resolution of the barrier and obtain
+ * information on which blockers have not been resolved yet.
+ *
+ * @param {string} name The name of the blocker. Used mainly for error-
+ *     reporting.
+ */
+function Barrier(name) {
+  if (!name) {
+    throw new TypeError("Instances of Barrier need a (non-empty) name");
+  }
+
+
+  /**
+   * The set of all Promise for which we need to wait before the barrier
+   * is lifted. Note that this set may be changed while we are waiting.
+   *
+   * Set to `null` once the wait is complete.
+   */
+  this._waitForMe = new PromiseSet();
+
+  /**
+   * A map from conditions, as passed by users during the call to `addBlocker`,
+   * to `promise`, as present in `this._waitForMe`.
+   *
+   * Used to let users perform cleanup through `removeBlocker`.
+   * Set to `null` once the wait is complete.
+   *
+   * Key: condition (any, as passed by user)
+   * Value: promise used as a key in `this._waitForMe`. Note that there is
+   * no guarantee that the key is still present in `this._waitForMe`.
+   */
+  this._conditionToPromise = new Map();
+
+  /**
+   * A map from Promise, as present in `this._waitForMe` or
+   * `this._conditionToPromise`, to information on blockers.
+   *
+   * Key: Promise (as present in this._waitForMe or this._conditionToPromise).
+   * Value:  {
+   *  trigger: function,
+   *  promise,
+   *  name,
+   *  fetchState: function,
+   *  stack,
+   *  filename,
+   *  lineNumber
+   * };
+   */
+  this._promiseToBlocker = new Map();
+
+  /**
+   * The name of the barrier.
+   */
+  if (typeof name != "string") {
+    throw new TypeError("The name of the barrier must be a string");
+  }
+  this._name = name;
+
+  /**
+   * A cache for the promise returned by wait().
+   */
+  this._promise = null;
+
+  /**
+   * `true` once we have started waiting.
+   */
+  this._isStarted = false;
+
+  /**
+   * The capability of adding blockers. This object may safely be returned
+   * or passed to clients.
+   */
+  this.client = {
+    /**
+     * The name of the barrier owning this client.
+     */
+    get name() {
+      return name;
+    },
+
+    /**
+     * Register a blocker for the completion of this barrier.
+     *
+     * @param {string} name The human-readable name of the blocker. Used
+     * for debugging/error reporting. Please make sure that the name
+     * respects the following model: "Some Service: some action in progress" -
+     * for instance "OS.File: flushing all pending I/O";
+     * @param {function|promise|*} condition A condition blocking the
+     * completion of the phase. Generally, this is a function
+     * returning a promise. This function is evaluated during the
+     * phase and the phase is guaranteed to not terminate until the
+     * resulting promise is either resolved or rejected. If
+     * |condition| is not a function but another value |v|, it behaves
+     * as if it were a function returning |v|.
+     * @param {object*} details Optionally, an object with details
+     * that may be useful for error reporting, as a subset of of the following
+     * fields:
+     * - fetchState (strongly recommended) A function returning
+     *    information about the current state of the blocker as an
+     *    object. Used for providing more details when logging errors or
+     *    crashing.
+     * - stack. A string containing stack information. This module can
+     *    generally infer stack information if it is not provided.
+     * - lineNumber A number containing the line number for the caller.
+     *    This module can generally infer this information if it is not
+     *    provided.
+     * - filename A string containing the filename for the caller. This
+     *    module can generally infer  the information if it is not provided.
+     */
+    addBlocker: (name, condition, details) => {
+      if (typeof name != "string") {
+        throw new TypeError("Expected a human-readable name as first argument");
+      }
+      if (details && typeof details == "function") {
+        details = {
+          fetchState: details
+        };
+      } else if (!details) {
+        details = {};
+      }
+      if (typeof details != "object") {
+        throw new TypeError("Expected an object as third argument to `addBlocker`, got " + details);
+      }
+      if (!this._waitForMe) {
+        throw new Error(`Phase "${ this._name }" is finished, it is too late to register completion condition "${ name }"`);
+      }
+      debug(`Adding blocker ${ name } for phase ${ this._name }`);
+
+      // Normalize the details
+
+      let fetchState = details.fetchState || null;
+      if (fetchState != null && typeof fetchState != "function") {
+        throw new TypeError("Expected a function for option `fetchState`");
+      }
+      let filename = details.filename || null;
+      let lineNumber = details.lineNumber || null;
+      let stack = details.stack || null;
+
+      // Split the condition between a trigger function and a promise.
+
+      // The function to call to notify the blocker that we have started waiting.
+      // This function returns a promise resolved/rejected once the
+      // condition is complete, and never throws.
+      let trigger;
+
+      // A promise resolved once the condition is complete.
+      let promise;
+      if (typeof condition == "function") {
+        promise = new Promise((resolve, reject) => {
+          trigger = () => {
+            try {
+              resolve(condition());
+            } catch (ex) {
+              reject(ex);
+            }
+          }
+        });
+      } else {
+        // If `condition` is not a function, `trigger` is not particularly
+        // interesting, and `condition` needs to be normalized to a promise.
+        trigger = () => {};
+        promise = Promise.resolve(condition);
+      }
+
+      // Make sure that `promise` never rejects.
+      promise = promise.then(null, error => {
+        let msg = `A blocker encountered an error while we were waiting.
+          Blocker:  ${ name }
+          Phase: ${ this._name }
+          State: ${ safeGetState(fetchState) }`;
+        warn(msg, error);
+
+        // The error should remain uncaught, to ensure that it
+        // still causes tests to fail.
+        Promise.reject(error);
+      }).catch(
+        // Added as a last line of defense, in case `warn`, `this._name` or
+        // `safeGetState` somehow throws an error.
+      );
+
+      let topFrame = null;
+      if (filename == null || lineNumber == null || stack == null) {
+        topFrame = Components.stack;
+      }
+
+      let blocker = {
+        trigger: trigger,
+        promise: promise,
+        name: name,
+        fetchState: fetchState,
+        getOrigin: () => getOrigin(topFrame, filename, lineNumber, stack),
+      };
+
+      this._waitForMe.add(promise);
+      this._promiseToBlocker.set(promise, blocker);
+      this._conditionToPromise.set(condition, promise);
+
+      // As conditions may hold lots of memory, we attempt to cleanup
+      // as soon as we are done (which might be in the next tick, if
+      // we have been passed a resolved promise).
+      promise = promise.then(() => {
+        debug(`Completed blocker ${ name } for phase ${ this._name }`);
+        this._removeBlocker(condition);
+      });
+
+      if (this._isStarted) {
+        // The wait has already started. The blocker should be
+        // notified asap. We do it out of band as clients probably
+        // expect `addBlocker` to return immediately.
+        Promise.resolve().then(trigger);
+      }
+    },
+
+    /**
+     * Remove the blocker for a condition.
+     *
+     * If several blockers have been registered for the same
+     * condition, remove all these blockers. If no blocker has been
+     * registered for this condition, this is a noop.
+     *
+     * @return {boolean} true if at least one blocker has been
+     * removed, false otherwise.
+     */
+    removeBlocker: (condition) => {
+      return this._removeBlocker(condition);
+    }
+  };
+}
+Barrier.prototype = Object.freeze({
+  /**
+   * The current state of the barrier, as a JSON-serializable object
+   * designed for error-reporting.
+   */
+  get state() {
+    if (!this._isStarted) {
+      return "Not started";
+    }
+    if (!this._waitForMe) {
+      return "Complete";
+    }
+    let frozen = [];
+    for (let blocker of this._promiseToBlocker.values()) {
+      let {name, fetchState} = blocker;
+      let {stack, filename, lineNumber} = blocker.getOrigin();
+      frozen.push({
+        name: name,
+        state: safeGetState(fetchState),
+        filename: filename,
+        lineNumber: lineNumber,
+        stack: stack
+      });
+    }
+    return frozen;
+  },
+
+  /**
+   * Wait until all currently registered blockers are complete.
+   *
+   * Once this method has been called, any attempt to register a new blocker
+   * for this barrier will cause an error.
+   *
+   * Successive calls to this method always return the same value.
+   *
+   * @param {object=}  options Optionally, an object  that may contain
+   * the following fields:
+   *  {number} warnAfterMS If provided and > 0, print a warning if the barrier
+   *   has not been resolved after the given number of milliseconds.
+   *  {number} crashAfterMS If provided and > 0, crash the process if the barrier
+   *   has not been resolved after the give number of milliseconds (rounded up
+   *   to the next second). To avoid crashing simply because the computer is busy
+   *   or going to sleep, we actually wait for ceil(crashAfterMS/1000) successive
+   *   periods of at least one second. Upon crashing, if a crash reporter is present,
+   *   prepare a crash report with the state of this barrier.
+   *
+   *
+   * @return {Promise} A promise satisfied once all blockers are complete.
+   */
+  wait: function(options = {}) {
+    // This method only implements caching on top of _wait()
+    if (this._promise) {
+      return this._promise;
+    }
+    return this._promise = this._wait(options);
+  },
+  _wait: function(options) {
+
+    // Sanity checks
+    if (this._isStarted) {
+      throw new TypeError("Internal error: already started " + this._name);
+    }
+    if (!this._waitForMe || !this._conditionToPromise || !this._promiseToBlocker) {
+      throw new TypeError("Internal error: already finished " + this._name);
+    }
+
+    let topic = this._name;
+
+    // Notify blockers
+    for (let blocker of this._promiseToBlocker.values()) {
+      blocker.trigger(); // We have guarantees that this method will never throw
+    }
+
+    this._isStarted = true;
+
+    // Now, wait
+    let promise = this._waitForMe.wait();
+
+    promise = promise.then(null, function onError(error) {
+      // I don't think that this can happen.
+      // However, let's be overcautious with async/shutdown error reporting.
+      let msg = "An uncaught error appeared while completing the phase." +
+        " Phase: " + topic;
+      warn(msg, error);
+    });
+
+    promise = promise.then(() => {
+      // Cleanup memory
+      this._waitForMe = null;
+      this._promiseToBlocker = null;
+      this._conditionToPromise = null;
+    });
+
+    // Now handle warnings and crashes
+    let warnAfterMS = DELAY_WARNING_MS;
+    if (options && "warnAfterMS" in options) {
+      if (typeof options.warnAfterMS == "number"
+         || options.warnAfterMS == null) {
+        // Change the delay or deactivate warnAfterMS
+        warnAfterMS = options.warnAfterMS;
+      } else {
+        throw new TypeError("Wrong option value for warnAfterMS");
+      }
+    }
+
+    if (warnAfterMS && warnAfterMS > 0) {
+      // If the promise takes too long to be resolved/rejected,
+      // we need to notify the user.
+      let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+      timer.initWithCallback(() => {
+        let msg = "At least one completion condition is taking too long to complete." +
+        " Conditions: " + JSON.stringify(this.state) +
+        " Barrier: " + topic;
+        warn(msg);
+      }, warnAfterMS, Ci.nsITimer.TYPE_ONE_SHOT);
+
+      promise = promise.then(function onSuccess() {
+        timer.cancel();
+        // As a side-effect, this prevents |timer| from
+        // being garbage-collected too early.
+      });
+    }
+
+    let crashAfterMS = DELAY_CRASH_MS;
+    if (options && "crashAfterMS" in options) {
+      if (typeof options.crashAfterMS == "number"
+         || options.crashAfterMS == null) {
+        // Change the delay or deactivate crashAfterMS
+        crashAfterMS = options.crashAfterMS;
+      } else {
+        throw new TypeError("Wrong option value for crashAfterMS");
+      }
+    }
+
+    if (crashAfterMS  > 0) {
+      let timeToCrash = null;
+
+      // If after |crashAfterMS| milliseconds (adjusted to take into
+      // account sleep and otherwise busy computer) we have not finished
+      // this shutdown phase, we assume that the shutdown is somehow
+      // frozen, presumably deadlocked. At this stage, the only thing we
+      // can do to avoid leaving the user's computer in an unstable (and
+      // battery-sucking) situation is report the issue and crash.
+      timeToCrash = looseTimer(crashAfterMS);
+      timeToCrash.promise.then(
+        function onTimeout() {
+          // Report the problem as best as we can, then crash.
+          let state = this.state;
+
+          // If you change the following message, please make sure
+          // that any information on the topic and state appears
+          // within the first 200 characters of the message. This
+          // helps automatically sort oranges.
+          let msg = "AsyncShutdown timeout in " + topic +
+            " Conditions: " + JSON.stringify(state) +
+            " At least one completion condition failed to complete" +
+            " within a reasonable amount of time. Causing a crash to" +
+            " ensure that we do not leave the user with an unresponsive" +
+            " process draining resources.";
+          fatalerr(msg);
+          if (gCrashReporter && gCrashReporter.enabled) {
+            let data = {
+              phase: topic,
+              conditions: state
+            };
+            gCrashReporter.annotateCrashReport("AsyncShutdownTimeout",
+              JSON.stringify(data));
+          } else {
+            warn("No crash reporter available");
+          }
+
+          // To help sorting out bugs, we want to make sure that the
+          // call to nsIDebug2.abort points to a guilty client, rather
+          // than to AsyncShutdown itself. We pick a client that is
+          // still blocking and use its filename/lineNumber,
+          // which have been determined during the call to `addBlocker`.
+          let filename = "?";
+          let lineNumber = -1;
+          for (let blocker of this._promiseToBlocker.values()) {
+            ({filename, lineNumber} = blocker.getOrigin());
+            break;
+          }
+          gDebug.abort(filename, lineNumber);
+        }.bind(this),
+        function onSatisfied() {
+          // The promise has been rejected, which means that we have satisfied
+          // all completion conditions.
+        });
+
+      promise = promise.then(function() {
+        timeToCrash.reject();
+      }/* No error is possible here*/);
+    }
+
+    return promise;
+  },
+
+  _removeBlocker: function(condition) {
+    if (!this._waitForMe || !this._promiseToBlocker || !this._conditionToPromise) {
+      // We have already cleaned up everything.
+      return false;
+    }
+
+    let promise = this._conditionToPromise.get(condition);
+    if (!promise) {
+      // The blocker has already been removed
+      return false;
+    }
+    this._conditionToPromise.delete(condition);
+    this._promiseToBlocker.delete(promise);
+    return this._waitForMe.delete(promise);
+  },
+
+});
+
+
+
+// List of well-known phases
+// Ideally, phases should be registered from the component that decides
+// when they start/stop. For compatibility with existing startup/shutdown
+// mechanisms, we register a few phases here.
+
+// Parent process
+if (!isContent) {
+  this.AsyncShutdown.profileChangeTeardown = getPhase("profile-change-teardown");
+  this.AsyncShutdown.profileBeforeChange = getPhase("profile-before-change");
+  this.AsyncShutdown.placesClosingInternalConnection = getPhase("places-will-close-connection");
+  this.AsyncShutdown.sendTelemetry = getPhase("profile-before-change-telemetry");
+}
+
+// Notifications that fire in the parent and content process, but should
+// only have phases in the parent process.
+if (!isContent) {
+  this.AsyncShutdown.quitApplicationGranted = getPhase("quit-application-granted");
+}
+
+// Don't add a barrier for content-child-shutdown because this
+// makes it easier to cause shutdown hangs.
+
+// All processes
+this.AsyncShutdown.webWorkersShutdown = getPhase("web-workers-shutdown");
+this.AsyncShutdown.xpcomWillShutdown = getPhase("xpcom-will-shutdown");
+
+this.AsyncShutdown.Barrier = Barrier;
+
+Object.freeze(this.AsyncShutdown);
diff --git a/toolkit/components/asyncshutdown/moz.build b/toolkit/components/asyncshutdown/moz.build
new file mode 100644
index 000000000..79a4c44c7
--- /dev/null
+++ b/toolkit/components/asyncshutdown/moz.build
@@ -0,0 +1,25 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += ['tests/xpcshell/xpcshell.ini']
+
+XPIDL_MODULE = 'toolkit_asyncshutdown'
+
+XPIDL_SOURCES += [
+    'nsIAsyncShutdown.idl',
+]
+
+EXTRA_JS_MODULES += [
+    'AsyncShutdown.jsm',
+]
+
+EXTRA_COMPONENTS += [
+    'nsAsyncShutdown.js',
+    'nsAsyncShutdown.manifest',
+]
+
+with Files('**'):
+    BUG_COMPONENT = ('Toolkit', 'Async Tooling')
diff --git a/toolkit/components/asyncshutdown/nsAsyncShutdown.js b/toolkit/components/asyncshutdown/nsAsyncShutdown.js
new file mode 100644
index 000000000..bd2c9a2fd
--- /dev/null
+++ b/toolkit/components/asyncshutdown/nsAsyncShutdown.js
@@ -0,0 +1,277 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * An implementation of nsIAsyncShutdown* based on AsyncShutdown.jsm
+ */
+
+"use strict";
+
+const Cu = Components.utils;
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cr = Components.results;
+
+var XPCOMUtils = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {}).XPCOMUtils;
+XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown",
+  "resource://gre/modules/AsyncShutdown.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+  "resource://gre/modules/Task.jsm");
+
+
+/**
+ * Conversion between nsIPropertyBag and JS object
+ */
+var PropertyBagConverter = {
+  // From nsIPropertyBag to JS
+  toObject: function(bag) {
+    if (!(bag instanceof Ci.nsIPropertyBag)) {
+      throw new TypeError("Not a property bag");
+    }
+    let result = {};
+    let enumerator = bag.enumerator;
+    while (enumerator.hasMoreElements()) {
+      let {name, value: property} = enumerator.getNext().QueryInterface(Ci.nsIProperty);
+      let value = this.toValue(property);
+      result[name] = value;
+    }
+    return result;
+  },
+  toValue: function(property) {
+    if (typeof property != "object") {
+      return property;
+    }
+    if (Array.isArray(property)) {
+      return property.map(this.toValue, this);
+    }
+    if (property && property instanceof Ci.nsIPropertyBag) {
+      return this.toObject(property);
+    }
+    return property;
+  },
+
+  // From JS to nsIPropertyBag
+  fromObject: function(obj) {
+    if (obj == null || typeof obj != "object") {
+      throw new TypeError("Invalid object: " + obj);
+    }
+    let bag = Cc["@mozilla.org/hash-property-bag;1"].
+      createInstance(Ci.nsIWritablePropertyBag);
+    for (let k of Object.keys(obj)) {
+      let value = this.fromValue(obj[k]);
+      bag.setProperty(k, value);
+    }
+    return bag;
+  },
+  fromValue: function(value) {
+    if (typeof value == "function") {
+      return null; // Emulating the behavior of JSON.stringify with functions
+    }
+    if (Array.isArray(value)) {
+      return value.map(this.fromValue, this);
+    }
+    if (value == null || typeof value != "object") {
+      // Auto-converted to nsIVariant
+      return value;
+    }
+    return this.fromObject(value);
+  },
+};
+
+
+
+/**
+ * Construct an instance of nsIAsyncShutdownClient from a
+ * AsyncShutdown.Barrier client.
+ *
+ * @param {object} moduleClient A client, as returned from the `client`
+ * property of an instance of `AsyncShutdown.Barrier`. This client will
+ * serve as back-end for methods `addBlocker` and `removeBlocker`.
+ * @constructor
+ */
+function nsAsyncShutdownClient(moduleClient) {
+  if (!moduleClient) {
+    throw new TypeError("nsAsyncShutdownClient expects one argument");
+  }
+  this._moduleClient = moduleClient;
+  this._byName = new Map();
+}
+nsAsyncShutdownClient.prototype = {
+  _getPromisified: function(xpcomBlocker) {
+    let candidate = this._byName.get(xpcomBlocker.name);
+    if (!candidate) {
+      return null;
+    }
+    if (candidate.xpcom === xpcomBlocker) {
+      return candidate.jsm;
+    }
+    return null;
+  },
+  _setPromisified: function(xpcomBlocker, moduleBlocker) {
+    let candidate = this._byName.get(xpcomBlocker.name);
+    if (!candidate) {
+      this._byName.set(xpcomBlocker.name, {xpcom: xpcomBlocker,
+                                           jsm: moduleBlocker});
+      return;
+    }
+    if (candidate.xpcom === xpcomBlocker) {
+      return;
+    }
+    throw new Error("We have already registered a distinct blocker with the same name: " + xpcomBlocker.name);
+  },
+  _deletePromisified: function(xpcomBlocker) {
+    let candidate = this._byName.get(xpcomBlocker.name);
+    if (!candidate || candidate.xpcom !== xpcomBlocker) {
+      return false;
+    }
+    this._byName.delete(xpcomBlocker.name);
+    return true;
+  },
+  get jsclient() {
+    return this._moduleClient;
+  },
+  get name() {
+    return this._moduleClient.name;
+  },
+  addBlocker: function(/* nsIAsyncShutdownBlocker*/ xpcomBlocker,
+      fileName, lineNumber, stack) {
+    // We need a Promise-based function with the same behavior as
+    // `xpcomBlocker`. Furthermore, to support `removeBlocker`, we
+    // need to ensure that we always get the same Promise-based
+    // function if we call several `addBlocker`/`removeBlocker` several
+    // times with the same `xpcomBlocker`.
+    //
+    // Ideally, this should be done with a WeakMap() with xpcomBlocker
+    // as a key, but XPConnect NativeWrapped objects cannot serve as
+    // WeakMap keys.
+    //
+    let moduleBlocker = this._getPromisified(xpcomBlocker);
+    if (!moduleBlocker) {
+      moduleBlocker = () => new Promise(
+        // This promise is never resolved. By opposition to AsyncShutdown
+        // blockers, `nsIAsyncShutdownBlocker`s are always lifted by calling
+        // `removeBlocker`.
+        () => xpcomBlocker.blockShutdown(this)
+      );
+
+      this._setPromisified(xpcomBlocker, moduleBlocker);
+    }
+
+    this._moduleClient.addBlocker(xpcomBlocker.name,
+      moduleBlocker,
+      {
+        fetchState: () => {
+          let state = xpcomBlocker.state;
+          if (state) {
+            return PropertyBagConverter.toValue(state);
+          }
+          return null;
+        },
+        filename: fileName,
+        lineNumber: lineNumber,
+        stack: stack,
+      });
+  },
+
+  removeBlocker: function(xpcomBlocker) {
+    let moduleBlocker = this._getPromisified(xpcomBlocker);
+    if (!moduleBlocker) {
+      return false;
+    }
+    this._deletePromisified(xpcomBlocker);
+    return this._moduleClient.removeBlocker(moduleBlocker);
+  },
+
+  /* ........ QueryInterface .............. */
+  QueryInterface :  XPCOMUtils.generateQI([Ci.nsIAsyncShutdownBarrier]),
+  classID:          Components.ID("{314e9e96-cc37-4d5c-843b-54709ce11426}"),
+};
+
+/**
+ * Construct an instance of nsIAsyncShutdownBarrier from an instance
+ * of AsyncShutdown.Barrier.
+ *
+ * @param {object} moduleBarrier an instance if
+ * `AsyncShutdown.Barrier`. This instance will serve as back-end for
+ * all methods.
+ * @constructor
+ */
+function nsAsyncShutdownBarrier(moduleBarrier) {
+  this._client = new nsAsyncShutdownClient(moduleBarrier.client);
+  this._moduleBarrier = moduleBarrier;
+}
+nsAsyncShutdownBarrier.prototype = {
+  get state() {
+    return PropertyBagConverter.fromValue(this._moduleBarrier.state);
+  },
+  get client() {
+    return this._client;
+  },
+  wait: function(onReady) {
+    this._moduleBarrier.wait().then(() => {
+      onReady.done();
+    });
+    // By specification, _moduleBarrier.wait() cannot reject.
+  },
+
+  /* ........ QueryInterface .............. */
+  QueryInterface :  XPCOMUtils.generateQI([Ci.nsIAsyncShutdownBarrier]),
+  classID:          Components.ID("{29a0e8b5-9111-4c09-a0eb-76cd02bf20fa}"),
+};
+
+function nsAsyncShutdownService() {
+  // Cache for the getters
+
+  for (let _k of
+   [// Parent process
+    "profileBeforeChange",
+    "profileChangeTeardown",
+    "quitApplicationGranted",
+    "sendTelemetry",
+
+    // Child processes
+    "contentChildShutdown",
+
+    // All processes
+    "webWorkersShutdown",
+    "xpcomWillShutdown",
+    ]) {
+    let k = _k;
+    Object.defineProperty(this, k, {
+      configurable: true,
+      get: function() {
+        delete this[k];
+        let wrapped = AsyncShutdown[k]; // May be undefined, if we're on the wrong process.
+        let result = wrapped ? new nsAsyncShutdownClient(wrapped) : undefined;
+        Object.defineProperty(this, k, {
+          value: result
+        });
+        return result;
+      }
+    });
+  }
+
+  // Hooks for testing purpose
+  this.wrappedJSObject = {
+    _propertyBagConverter: PropertyBagConverter
+  };
+}
+nsAsyncShutdownService.prototype = {
+  makeBarrier: function(name) {
+    return new nsAsyncShutdownBarrier(new AsyncShutdown.Barrier(name));
+  },
+
+  /* ........ QueryInterface .............. */
+  QueryInterface :  XPCOMUtils.generateQI([Ci.nsIAsyncShutdownService]),
+  classID:          Components.ID("{35c496de-a115-475d-93b5-ffa3f3ae6fe3}"),
+};
+
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([
+    nsAsyncShutdownService,
+    nsAsyncShutdownBarrier,
+    nsAsyncShutdownClient,
+]);
diff --git a/toolkit/components/asyncshutdown/nsAsyncShutdown.manifest b/toolkit/components/asyncshutdown/nsAsyncShutdown.manifest
new file mode 100644
index 000000000..67f247902
--- /dev/null
+++ b/toolkit/components/asyncshutdown/nsAsyncShutdown.manifest
@@ -0,0 +1,2 @@
+component {35c496de-a115-475d-93b5-ffa3f3ae6fe3} nsAsyncShutdown.js
+contract @mozilla.org/async-shutdown-service;1 {35c496de-a115-475d-93b5-ffa3f3ae6fe3}
diff --git a/toolkit/components/asyncshutdown/nsIAsyncShutdown.idl b/toolkit/components/asyncshutdown/nsIAsyncShutdown.idl
new file mode 100644
index 000000000..216c8047e
--- /dev/null
+++ b/toolkit/components/asyncshutdown/nsIAsyncShutdown.idl
@@ -0,0 +1,220 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * A mechanism for specifying shutdown dependencies between
+ * asynchronous services.
+ *
+ * Note that this XPCOM component is designed primarily for C++
+ * clients. JavaScript clients should rather use AsyncShutdown.jsm,
+ * which provides a better API and better error reporting for them.
+ */
+
+
+#include "nsISupports.idl"
+#include "nsIPropertyBag.idl"
+#include "nsIVariant.idl"
+
+interface nsIAsyncShutdownClient;
+
+/**
+ * A blocker installed by a client to be informed during some stage of
+ * shutdown and block shutdown asynchronously until some condition is
+ * complete.
+ *
+ * If you wish to use AsyncShutdown, you will need to implement this
+ * interface (and only this interface).
+ */
+[scriptable, uuid(4ef43f29-6715-4b57-a750-2ff83695ddce)]
+interface nsIAsyncShutdownBlocker: nsISupports {
+  /**
+   * The *unique* name of the blocker.
+   *
+   * By convention, it should respect the following format:
+   * "MyModuleName: Doing something while it's time"
+   * e.g.
+   * "OS.File: Flushing before profile-before-change"
+   *
+   * This attribute is uploaded as part of crash reports.
+   */
+  readonly attribute AString name;
+
+  /**
+   * Inform the blocker that the stage of shutdown has started.
+   * Shutdown will NOT proceed until `aBarrierClient.removeBlocker(this)`
+   * has been called.
+   */
+  void blockShutdown(in nsIAsyncShutdownClient aBarrierClient);
+
+  /**
+   * The current state of the blocker.
+   *
+   * In case of crash, this is converted to JSON and attached to
+   * the crash report.
+   *
+   * This field may be used to provide JSON-style data structures.
+   * For this purpose, use
+   * - nsIPropertyBag to represent objects;
+   * - nsIVariant to represent field values (which may hold nsIPropertyBag
+   * themselves).
+   */
+  readonly attribute nsIPropertyBag state;
+};
+
+/**
+ * A client for a nsIAsyncShutdownBarrier.
+ */
+[scriptable, uuid(d2031049-b990-43a2-95be-59f8a3ca5954)]
+interface nsIAsyncShutdownClient: nsISupports {
+  /**
+   * The name of the barrier.
+   */
+  readonly attribute AString name;
+
+  /**
+   * Add a blocker.
+   *
+   * After a `blocker` has been added with `addBlocker`, if it is not
+   * removed with `removeBlocker`, this will, by design, eventually
+   * CAUSE A CRASH.
+   *
+   * Calling `addBlocker` once nsIAsyncShutdownBarrier::wait() has been
+   * called on the owning barrier returns an error.
+   *
+   * @param aBlocker The blocker to add. Once
+   * nsIAsyncShutdownBarrier::wait() has been called, it will not
+   * call its `aOnReady` callback until all blockers have been
+   * removed, each  by a call to `removeBlocker`.
+   * @param aFileName The filename of the callsite, as given by `__FILE__`.
+   * @param aLineNumber The linenumber of the callsite, as given by `__LINE__`.
+   * @param aStack Information on the stack that lead to this call. Generally
+   * empty when called from C++.
+   */
+  void addBlocker(in nsIAsyncShutdownBlocker aBlocker,
+                  in AString aFileName,
+                  in long aLineNumber,
+                  in AString aStack);
+
+  /**
+   * Remove a blocker.
+   *
+   * @param aBlocker A blocker previously added to this client through
+   * `addBlocker`. Noop if the blocker has never been added or has been
+   * removed already.
+   */
+  void removeBlocker(in nsIAsyncShutdownBlocker aBlocker);
+
+  /**
+   * The JS implementation of the client.
+   *
+   * It is strongly recommended that JS clients of this API use
+   * `jsclient` instead of the `nsIAsyncShutdownClient`. See
+   * AsyncShutdown.jsm for more information on the JS version of
+   * this API.
+   */
+  readonly attribute jsval jsclient;
+};
+
+/**
+ * Callback invoked once all blockers of a barrier have been removed.
+ */
+[scriptable, function, uuid(910c9309-1da0-4dd0-8bdb-a325a38c604e)]
+interface nsIAsyncShutdownCompletionCallback: nsISupports {
+  /**
+   * The operation has been completed.
+   */
+  void done();
+};
+
+/**
+ * A stage of shutdown that supports blocker registration.
+ */
+[scriptable, uuid(50fa8a86-9c91-4256-8389-17d310adec90)]
+interface nsIAsyncShutdownBarrier: nsISupports {
+
+  /**
+   * The blocker registration capability.  Most services may wish to
+   * publish this capability to let services that depend on it register
+   * blockers.
+   */
+  readonly attribute nsIAsyncShutdownClient client;
+
+  /**
+   * The state of all the blockers of the barrier.
+   *
+   * See the documentation of `nsIAsyncShutdownBlocker` for the
+   * format.
+   */
+  readonly attribute nsIPropertyBag state;
+
+  /**
+   * Wait for all blockers to complete.
+   *
+   * Method `aOnReady` will be called once all blockers have finished.
+   * The callback always receives NS_OK.
+   */
+  void wait(in nsIAsyncShutdownCompletionCallback aOnReady);
+};
+
+/**
+ * A service that allows registering shutdown-time dependencies.
+ */
+[scriptable, uuid(db365c78-c860-4e64-9a63-25b73f89a016)]
+interface nsIAsyncShutdownService: nsISupports {
+  /**
+   * Create a new barrier.
+   *
+   * By convention, the name should respect the following format:
+   * "MyModuleName: Doing something while it's time"
+   * e.g.
+   * "OS.File: Waiting for clients to flush before shutting down"
+   *
+   * This attribute is uploaded as part of crash reports.
+   */
+  nsIAsyncShutdownBarrier makeBarrier(in AString aName);
+
+
+  // Barriers for global shutdown stages in the parent process.
+
+  /**
+   * Barrier for notification profile-before-change.
+   */
+  readonly attribute nsIAsyncShutdownClient profileBeforeChange;
+
+  /**
+   * Barrier for notification profile-change-teardown.
+   */
+  readonly attribute nsIAsyncShutdownClient profileChangeTeardown;
+
+  /**
+   * Barrier for notification quit-application-granted.
+   */
+  readonly attribute nsIAsyncShutdownClient quitApplicationGranted;
+
+  /**
+   * Barrier for notification profile-before-change-telemetry.
+   */
+  readonly attribute nsIAsyncShutdownClient sendTelemetry;
+
+
+  // Barriers for global shutdown stages in all processes.
+
+  /**
+   * Barrier for notification web-workers-shutdown.
+   */
+  readonly attribute nsIAsyncShutdownClient webWorkersShutdown;
+
+  /**
+   * Barrier for notification xpcom-will-shutdown.
+   */
+  readonly attribute nsIAsyncShutdownClient xpcomWillShutdown;
+
+  // Don't add a barrier for content-child-shutdown because this
+  // makes it easier to cause shutdown hangs.
+
+};
+
+%{C++
+#define NS_ASYNCSHUTDOWNSERVICE_CONTRACTID "@mozilla.org/async-shutdown-service;1"
+%}
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/.eslintrc.js b/toolkit/components/asyncshutdown/tests/xpcshell/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/head.js b/toolkit/components/asyncshutdown/tests/xpcshell/head.js
new file mode 100644
index 000000000..9de489808
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/head.js
@@ -0,0 +1,174 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+var Cu = Components.utils;
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/AsyncShutdown.jsm");
+
+var asyncShutdownService = Cc["@mozilla.org/async-shutdown-service;1"].
+  getService(Ci.nsIAsyncShutdownService);
+
+
+Services.prefs.setBoolPref("toolkit.asyncshutdown.testing", true);
+
+/**
+ * Utility function used to provide the same API for various sources
+ * of async shutdown barriers.
+ *
+ * @param {string} kind One of
+ * - "phase" to test an AsyncShutdown phase;
+ * - "barrier" to test an instance of AsyncShutdown.Barrier;
+ * - "xpcom-barrier" to test an instance of nsIAsyncShutdownBarrier;
+ * - "xpcom-barrier-unwrapped" to test the field `jsclient` of a nsIAsyncShutdownClient.
+ *
+ * @return An object with the following methods:
+ *   - addBlocker() - the same method as AsyncShutdown phases and barrier clients
+ *   - wait() - trigger the resolution of the lock
+ */
+function makeLock(kind) {
+  if (kind == "phase") {
+    let topic = "test-Phase-" + ++makeLock.counter;
+    let phase = AsyncShutdown._getPhase(topic);
+    return {
+      addBlocker: function(...args) {
+        return phase.addBlocker(...args);
+      },
+      removeBlocker: function(blocker) {
+        return phase.removeBlocker(blocker);
+      },
+      wait: function() {
+        Services.obs.notifyObservers(null, topic, null);
+        return Promise.resolve();
+      }
+    };
+  } else if (kind == "barrier") {
+    let name = "test-Barrier-" + ++makeLock.counter;
+    let barrier = new AsyncShutdown.Barrier(name);
+    return {
+      addBlocker: barrier.client.addBlocker,
+      removeBlocker: barrier.client.removeBlocker,
+      wait: function() {
+        return barrier.wait();
+      }
+    };
+  } else if (kind == "xpcom-barrier") {
+    let name = "test-xpcom-Barrier-" + ++makeLock.counter;
+    let barrier = asyncShutdownService.makeBarrier(name);
+    return {
+      addBlocker: function(blockerName, condition, state) {
+        if (condition == null) {
+          // Slight trick as `null` or `undefined` cannot be used as keys
+          // for `xpcomMap`. Note that this has no incidence on the result
+          // of the test as the XPCOM interface imposes that the condition
+          // is a method, so it cannot be `null`/`undefined`.
+          condition = "<this case can't happen with the xpcom interface>";
+        }
+        let blocker = makeLock.xpcomMap.get(condition);
+        if (!blocker) {
+          blocker = {
+            name: blockerName,
+            state: state,
+            blockShutdown: function(aBarrierClient) {
+              return Task.spawn(function*() {
+                try {
+                  if (typeof condition == "function") {
+                    yield Promise.resolve(condition());
+                  } else {
+                    yield Promise.resolve(condition);
+                  }
+                } finally {
+                  aBarrierClient.removeBlocker(blocker);
+                }
+              });
+            },
+          };
+          makeLock.xpcomMap.set(condition, blocker);
+        }
+        let {fileName, lineNumber, stack} = (new Error());
+        return barrier.client.addBlocker(blocker, fileName, lineNumber, stack);
+      },
+      removeBlocker: function(condition) {
+        let blocker = makeLock.xpcomMap.get(condition);
+        if (!blocker) {
+          return;
+        }
+        barrier.client.removeBlocker(blocker);
+      },
+      wait: function() {
+        return new Promise(resolve => {
+          barrier.wait(resolve);
+        });
+      }
+    };
+  } else if ("unwrapped-xpcom-barrier") {
+    let name = "unwrapped-xpcom-barrier-" + ++makeLock.counter;
+    let barrier = asyncShutdownService.makeBarrier(name);
+    let client = barrier.client.jsclient;
+    return {
+      addBlocker: client.addBlocker,
+      removeBlocker: client.removeBlocker,
+      wait: function() {
+        return new Promise(resolve => {
+          barrier.wait(resolve);
+        });
+      }
+    };
+  }
+  throw new TypeError("Unknown kind " + kind);
+}
+makeLock.counter = 0;
+makeLock.xpcomMap = new Map(); // Note: Not a WeakMap as we wish to handle non-gc-able keys (e.g. strings)
+
+/**
+ * An asynchronous task that takes several ticks to complete.
+ *
+ * @param {*=} resolution The value with which the resulting promise will be
+ * resolved once the task is complete. This may be a rejected promise,
+ * in which case the resulting promise will itself be rejected.
+ * @param {object=} outResult An object modified by side-effect during the task.
+ * Initially, its field |isFinished| is set to |false|. Once the task is
+ * complete, its field |isFinished| is set to |true|.
+ *
+ * @return {promise} A promise fulfilled once the task is complete
+ */
+function longRunningAsyncTask(resolution = undefined, outResult = {}) {
+  outResult.isFinished = false;
+  if (!("countFinished" in outResult)) {
+    outResult.countFinished = 0;
+  }
+  let deferred = Promise.defer();
+  do_timeout(100, function() {
+    ++outResult.countFinished;
+    outResult.isFinished = true;
+    deferred.resolve(resolution);
+  });
+  return deferred.promise;
+}
+
+function get_exn(f) {
+  try {
+    f();
+    return null;
+  } catch (ex) {
+    return ex;
+  }
+}
+
+function do_check_exn(exn, constructor) {
+  do_check_neq(exn, null);
+  if (exn.name == constructor) {
+    do_check_eq(exn.constructor.name, constructor);
+    return;
+  }
+  do_print("Wrong error constructor");
+  do_print(exn.constructor.name);
+  do_print(exn.stack);
+  do_check_true(false);
+}
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown.js b/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown.js
new file mode 100644
index 000000000..f1aebc3ad
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown.js
@@ -0,0 +1,194 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+Cu.import("resource://gre/modules/PromiseUtils.jsm", this);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_no_condition() {
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+    do_print("Testing a barrier with no condition (" + kind + ")");
+    let lock = makeLock(kind);
+    yield lock.wait();
+    do_print("Barrier with no condition didn't lock");
+  }
+});
+
+add_task(function* test_phase_various_failures() {
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+    do_print("Kind: " + kind);
+    // Testing with wrong arguments
+    let lock = makeLock(kind);
+
+    Assert.throws(() => lock.addBlocker(), /TypeError|NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS/);
+    Assert.throws(() => lock.addBlocker(null, true), /TypeError|NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS/);
+
+    if (kind != "xpcom-barrier") {
+      // xpcom-barrier actually expects a string in that position
+      Assert.throws(() => lock.addBlocker("Test 2", () => true, "not a function"), /TypeError/);
+    }
+
+    // Attempting to add a blocker after we are done waiting
+    yield lock.wait();
+    Assert.throws(() => lock.addBlocker("Test 3", () => true), /is finished/);
+  }
+});
+
+add_task(function* test_reentrant() {
+  do_print("Ensure that we can call addBlocker from within a blocker");
+
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+    do_print("Kind: " + kind);
+    let lock = makeLock(kind);
+
+    let deferredOuter = PromiseUtils.defer();
+    let deferredInner = PromiseUtils.defer();
+    let deferredBlockInner = PromiseUtils.defer();
+
+    lock.addBlocker("Outer blocker", () => {
+      do_print("Entering outer blocker");
+      deferredOuter.resolve();
+      lock.addBlocker("Inner blocker", () => {
+        do_print("Entering inner blocker");
+        deferredInner.resolve();
+        return deferredBlockInner.promise;
+      });
+    });
+
+    // Note that phase-style locks spin the event loop and do not return from
+    // `lock.wait()` until after all blockers have been resolved. Therefore,
+    // to be able to test them, we need to dispatch the following steps to the
+    // event loop before calling `lock.wait()`, which we do by forcing
+    // a Promise.resolve().
+    //
+    let promiseSteps = Task.spawn(function* () {
+      yield Promise.resolve();
+
+      do_print("Waiting until we have entered the outer blocker");
+      yield deferredOuter.promise;
+
+      do_print("Waiting until we have entered the inner blocker");
+      yield deferredInner.promise;
+
+      do_print("Allowing the lock to resolve")
+      deferredBlockInner.resolve();
+    });
+
+    do_print("Starting wait");
+    yield lock.wait();
+
+    do_print("Waiting until all steps have been walked");
+    yield promiseSteps;
+  }
+});
+
+
+add_task(function* test_phase_removeBlocker() {
+  do_print("Testing that we can call removeBlocker before, during and after the call to wait()");
+
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+
+    do_print("Switching to kind " + kind);
+    do_print("Attempt to add then remove a blocker before wait()");
+    let lock = makeLock(kind);
+    let blocker = () => {
+      do_print("This promise will never be resolved");
+      return Promise.defer().promise;
+    };
+
+    lock.addBlocker("Wait forever", blocker);
+    let do_remove_blocker = function(aLock, aBlocker, aShouldRemove) {
+      do_print("Attempting to remove blocker " + aBlocker + ", expecting result " + aShouldRemove);
+      if (kind == "xpcom-barrier") {
+        // The xpcom variant always returns `undefined`, so we can't
+        // check its result.
+        aLock.removeBlocker(aBlocker);
+        return;
+      }
+      do_check_eq(aLock.removeBlocker(aBlocker), aShouldRemove);
+    };
+    do_remove_blocker(lock, blocker, true);
+    do_remove_blocker(lock, blocker, false);
+    do_print("Attempt to remove non-registered blockers before wait()");
+    do_remove_blocker(lock, "foo", false);
+    do_remove_blocker(lock, null, false);
+    do_print("Waiting (should lift immediately)");
+    yield lock.wait();
+
+    do_print("Attempt to add a blocker then remove it during wait()");
+    lock = makeLock(kind);
+    let blockers = [
+      () => {
+        do_print("This blocker will self-destruct");
+        do_remove_blocker(lock, blockers[0], true);
+        return Promise.defer().promise;
+      },
+      () => {
+        do_print("This blocker will self-destruct twice");
+        do_remove_blocker(lock, blockers[1], true);
+        do_remove_blocker(lock, blockers[1], false);
+        return Promise.defer().promise;
+      },
+      () => {
+        do_print("Attempt to remove non-registered blockers during wait()");
+        do_remove_blocker(lock, "foo", false);
+        do_remove_blocker(lock, null, false);
+      }
+    ];
+    for (let i in blockers) {
+      lock.addBlocker("Wait forever again: " + i, blockers[i]);
+    }
+    do_print("Waiting (should lift very quickly)");
+    yield lock.wait();
+    do_remove_blocker(lock, blockers[0], false);
+
+
+    do_print("Attempt to remove a blocker after wait");
+    lock = makeLock(kind);
+    blocker = Promise.resolve.bind(Promise);
+    yield lock.wait();
+    do_remove_blocker(lock, blocker, false);
+
+    do_print("Attempt to remove non-registered blocker after wait()");
+    do_remove_blocker(lock, "foo", false);
+    do_remove_blocker(lock, null, false);
+  }
+
+});
+
+add_task(function* test_state() {
+  do_print("Testing information contained in `state`");
+
+  let BLOCKER_NAME = "test_state blocker " + Math.random();
+
+  // Set up the barrier. Note that we cannot test `barrier.state`
+  // immediately, as it initially contains "Not started"
+  let barrier = new AsyncShutdown.Barrier("test_filename");
+  let deferred = Promise.defer();
+  let {filename, lineNumber} = Components.stack;
+  barrier.client.addBlocker(BLOCKER_NAME,
+    function() {
+      return deferred.promise;
+    });
+
+  let promiseDone = barrier.wait();
+
+  // Now that we have called `wait()`, the state contains interesting things
+  let state = barrier.state[0];
+  do_print("State: " + JSON.stringify(barrier.state, null, "\t"));
+  Assert.equal(state.filename, filename);
+  Assert.equal(state.lineNumber, lineNumber + 1);
+  Assert.equal(state.name, BLOCKER_NAME);
+  Assert.ok(state.stack.some(x => x.includes("test_state")), "The stack contains the caller function's name");
+  Assert.ok(state.stack.some(x => x.includes(filename)), "The stack contains the calling file's name");
+
+  deferred.resolve();
+  yield promiseDone;
+});
+
+add_task(function*() {
+  Services.prefs.clearUserPref("toolkit.asyncshutdown.testing");
+});
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown_leave_uncaught.js b/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown_leave_uncaught.js
new file mode 100644
index 000000000..33da1f53f
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/test_AsyncShutdown_leave_uncaught.js
@@ -0,0 +1,96 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+//
+// This file contains tests that need to leave uncaught asynchronous
+// errors. If your test catches all its asynchronous errors, please
+// put it in another file.
+//
+
+Promise.Debugging.clearUncaughtErrorObservers();
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_phase_simple_async() {
+  do_print("Testing various combinations of a phase with a single condition");
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+    for (let arg of [undefined, null, "foo", 100, new Error("BOOM")]) {
+      for (let resolution of [arg, Promise.reject(arg)]) {
+        for (let success of [false, true]) {
+          for (let state of [[null],
+                             [],
+                             [() => "some state"],
+                             [function() {
+                               throw new Error("State BOOM"); }],
+                             [function() {
+                               return {
+                                 toJSON: function() {
+                                   throw new Error("State.toJSON BOOM");
+                                 }
+                               };
+                             }]]) {
+            // Asynchronous phase
+            do_print("Asynchronous test with " + arg + ", " + resolution + ", " + kind);
+            let lock = makeLock(kind);
+            let outParam = { isFinished: false };
+            lock.addBlocker(
+              "Async test",
+               function() {
+                 if (success) {
+                   return longRunningAsyncTask(resolution, outParam);
+                 }
+                 throw resolution;
+               },
+               ...state
+            );
+            do_check_false(outParam.isFinished);
+            yield lock.wait();
+            do_check_eq(outParam.isFinished, success);
+          }
+        }
+
+        // Synchronous phase - just test that we don't throw/freeze
+        do_print("Synchronous test with " + arg + ", " + resolution + ", " + kind);
+        let lock = makeLock(kind);
+        lock.addBlocker(
+          "Sync test",
+          resolution
+        );
+        yield lock.wait();
+      }
+    }
+  }
+});
+
+add_task(function* test_phase_many() {
+  do_print("Testing various combinations of a phase with many conditions");
+  for (let kind of ["phase", "barrier", "xpcom-barrier", "xpcom-barrier-unwrapped"]) {
+    let lock = makeLock(kind);
+    let outParams = [];
+    for (let arg of [undefined, null, "foo", 100, new Error("BOOM")]) {
+      for (let resolve of [true, false]) {
+        do_print("Testing with " + kind + ", " + arg + ", " + resolve);
+        let resolution = resolve ? arg : Promise.reject(arg);
+        let outParam = { isFinished: false };
+        lock.addBlocker(
+          "Test " + Math.random(),
+          () => longRunningAsyncTask(resolution, outParam)
+        );
+      }
+    }
+    do_check_true(outParams.every((x) => !x.isFinished));
+    yield lock.wait();
+    do_check_true(outParams.every((x) => x.isFinished));
+  }
+});
+
+
+
+
+add_task(function*() {
+  Services.prefs.clearUserPref("toolkit.asyncshutdown.testing");
+});
+
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/test_converters.js b/toolkit/components/asyncshutdown/tests/xpcshell/test_converters.js
new file mode 100644
index 000000000..c6c923187
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/test_converters.js
@@ -0,0 +1,88 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+/**
+ * Test conversion between nsIPropertyBag and JS values.
+ */
+
+var PropertyBagConverter = asyncShutdownService.wrappedJSObject._propertyBagConverter;
+
+function run_test() {
+  test_conversions();
+}
+
+function normalize(obj) {
+  if (obj == null || typeof obj != "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(normalize);
+  }
+  let result = {};
+  for (let k of Object.keys(obj).sort()) {
+    result[k] = normalize(obj[k]);
+  }
+  return result;
+}
+
+function test_conversions() {
+  const SAMPLES = [
+    // Simple values
+    1,
+    true,
+    "string",
+    null,
+
+    // Objects
+    {
+      a: 1,
+      b: true,
+      c: "string",
+      d:.5,
+      e: [2, false, "another string", .3],
+      f: [],
+      g: {
+        a2: 1,
+        b2: true,
+        c2: "string",
+        d2:.5,
+        e2: [2, false, "another string", .3],
+        f2: [],
+        g2: [{
+          a3: 1,
+          b3: true,
+          c3: "string",
+          d3:.5,
+          e3: [2, false, "another string", .3],
+          f3: [],
+          g3: {}
+        }]
+      }
+    }];
+
+  for (let sample of SAMPLES) {
+    let stringified = JSON.stringify(normalize(sample), null, "\t");
+    do_print("Testing conversions of " + stringified);
+    let rewrites = [sample];
+    for (let i = 1; i < 3; ++i) {
+      let source = rewrites[i - 1];
+      let bag = PropertyBagConverter.fromValue(source);
+      do_print(" => " + bag);
+      if (source == null) {
+        Assert.ok(bag == null, "The bag is null");
+      } else if (typeof source == "object") {
+        Assert.ok(bag instanceof Ci.nsIPropertyBag, "The bag is a property bag");
+      } else {
+        Assert.ok(typeof bag != "object", "The bag is not an object");
+      }
+      let dest = PropertyBagConverter.toValue(bag);
+      let restringified = JSON.stringify(normalize(dest), null, "\t");
+      do_print("Comparing");
+      do_print(stringified);
+      do_print(restringified);
+      Assert.deepEqual(sample, dest, "Testing after " + i + " conversions");
+      rewrites.push(dest);
+    }
+  }
+}
diff --git a/toolkit/components/asyncshutdown/tests/xpcshell/xpcshell.ini b/toolkit/components/asyncshutdown/tests/xpcshell/xpcshell.ini
new file mode 100644
index 000000000..f573955bc
--- /dev/null
+++ b/toolkit/components/asyncshutdown/tests/xpcshell/xpcshell.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+head=head.js
+tail=
+skip-if = toolkit == 'android'
+
+[test_AsyncShutdown.js]
+[test_AsyncShutdown_leave_uncaught.js]
+[test_converters.js]