Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1304 insertions, 0 deletions

diff --git a/testing/specialpowers/content/SpecialPowersParent.jsm b/testing/specialpowers/content/SpecialPowersParent.jsm
new file mode 100644
index 0000000000..2aad29b6a5
--- /dev/null
+++ b/testing/specialpowers/content/SpecialPowersParent.jsm
@@ -0,0 +1,1304 @@
+/* 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/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["SpecialPowersParent"];
+
+const { AppConstants } = ChromeUtils.import(
+  "resource://gre/modules/AppConstants.jsm"
+);
+var { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  ExtensionData: "resource://gre/modules/Extension.jsm",
+  ExtensionTestCommon: "resource://testing-common/ExtensionTestCommon.jsm",
+  PerTestCoverageUtils: "resource://testing-common/PerTestCoverageUtils.jsm",
+  ServiceWorkerCleanUp: "resource://gre/modules/ServiceWorkerCleanUp.jsm",
+  SpecialPowersSandbox: "resource://specialpowers/SpecialPowersSandbox.jsm",
+  HiddenFrame: "resource://gre/modules/HiddenFrame.jsm",
+});
+
+class SpecialPowersError extends Error {
+  get name() {
+    return "SpecialPowersError";
+  }
+}
+
+function getTestPlugin(pluginName) {
+  var ph = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+  var tags = ph.getPluginTags();
+  var name = pluginName || "Test Plug-in";
+  for (var tag of tags) {
+    if (tag.name == name) {
+      return tag;
+    }
+  }
+
+  return null;
+}
+
+const PREF_TYPES = {
+  [Ci.nsIPrefBranch.PREF_INVALID]: "INVALID",
+  [Ci.nsIPrefBranch.PREF_INT]: "INT",
+  [Ci.nsIPrefBranch.PREF_BOOL]: "BOOL",
+  [Ci.nsIPrefBranch.PREF_STRING]: "CHAR",
+  number: "INT",
+  boolean: "BOOL",
+  string: "CHAR",
+};
+
+// We share a single preference environment stack between all
+// SpecialPowers instances, across all processes.
+let prefUndoStack = [];
+let inPrefEnvOp = false;
+
+let permissionUndoStack = [];
+
+function doPrefEnvOp(fn) {
+  if (inPrefEnvOp) {
+    throw new Error(
+      "Reentrant preference environment operations not supported"
+    );
+  }
+  inPrefEnvOp = true;
+  try {
+    return fn();
+  } finally {
+    inPrefEnvOp = false;
+  }
+}
+
+async function createWindowlessBrowser({ isPrivate = false } = {}) {
+  const {
+    promiseDocumentLoaded,
+    promiseEvent,
+    promiseObserved,
+  } = ChromeUtils.import(
+    "resource://gre/modules/ExtensionUtils.jsm"
+  ).ExtensionUtils;
+
+  let windowlessBrowser = Services.appShell.createWindowlessBrowser(true);
+
+  if (isPrivate) {
+    let loadContext = windowlessBrowser.docShell.QueryInterface(
+      Ci.nsILoadContext
+    );
+    loadContext.usePrivateBrowsing = true;
+  }
+
+  let chromeShell = windowlessBrowser.docShell.QueryInterface(
+    Ci.nsIWebNavigation
+  );
+
+  const system = Services.scriptSecurityManager.getSystemPrincipal();
+  chromeShell.createAboutBlankContentViewer(system, system);
+  windowlessBrowser.browsingContext.useGlobalHistory = false;
+  chromeShell.loadURI("chrome://extensions/content/dummy.xhtml", {
+    triggeringPrincipal: system,
+  });
+
+  await promiseObserved(
+    "chrome-document-global-created",
+    win => win.document == chromeShell.document
+  );
+
+  let chromeDoc = await promiseDocumentLoaded(chromeShell.document);
+
+  let browser = chromeDoc.createXULElement("browser");
+  browser.setAttribute("type", "content");
+  browser.setAttribute("disableglobalhistory", "true");
+  browser.setAttribute("remote", "true");
+
+  let promise = promiseEvent(browser, "XULFrameLoaderCreated");
+  chromeDoc.documentElement.appendChild(browser);
+
+  await promise;
+
+  return { windowlessBrowser, browser };
+}
+
+// Supplies the unique IDs for tasks created by SpecialPowers.spawn(),
+// used to bounce assertion messages back down to the correct child.
+let nextTaskID = 1;
+
+// The default actor to send assertions to if a task originated in a
+// window without a test harness.
+let defaultAssertHandler;
+
+class SpecialPowersParent extends JSWindowActorParent {
+  constructor() {
+    super();
+
+    this._messageManager = Services.mm;
+    this._serviceWorkerListener = null;
+
+    this._observer = this.observe.bind(this);
+
+    this.didDestroy = this.uninit.bind(this);
+
+    this._registerObservers = {
+      _self: this,
+      _topics: [],
+      _add(topic) {
+        if (!this._topics.includes(topic)) {
+          this._topics.push(topic);
+          Services.obs.addObserver(this, topic);
+        }
+      },
+      observe(aSubject, aTopic, aData) {
+        var msg = { aData };
+        switch (aTopic) {
+          case "csp-on-violate-policy":
+            // the subject is either an nsIURI or an nsISupportsCString
+            let subject = null;
+            if (aSubject instanceof Ci.nsIURI) {
+              subject = aSubject.asciiSpec;
+            } else if (aSubject instanceof Ci.nsISupportsCString) {
+              subject = aSubject.data;
+            } else {
+              throw new Error("Subject must be nsIURI or nsISupportsCString");
+            }
+            msg = {
+              subject,
+              data: aData,
+            };
+            this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
+            return;
+          case "xfo-on-violate-policy":
+            let uriSpec = null;
+            if (aSubject instanceof Ci.nsIURI) {
+              uriSpec = aSubject.asciiSpec;
+            } else {
+              throw new Error("Subject must be nsIURI");
+            }
+            msg = {
+              subject: uriSpec,
+              data: aData,
+            };
+            this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
+            return;
+          default:
+            this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
+        }
+      },
+    };
+
+    this.init();
+
+    this._crashDumpDir = null;
+    this._processCrashObserversRegistered = false;
+    this._chromeScriptListeners = [];
+    this._extensions = new Map();
+    this._taskActors = new Map();
+  }
+
+  init() {
+    Services.obs.addObserver(this._observer, "http-on-modify-request");
+
+    // We would like to check that tests don't leave service workers around
+    // after they finish, but that information lives in the parent process.
+    // Ideally, we'd be able to tell the child processes whenever service
+    // workers are registered or unregistered so they would know at all times,
+    // but service worker lifetimes are complicated enough to make that
+    // difficult. For the time being, let the child process know when a test
+    // registers a service worker so it can ask, synchronously, at the end if
+    // the service worker had unregister called on it.
+    let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
+      Ci.nsIServiceWorkerManager
+    );
+    let self = this;
+    this._serviceWorkerListener = {
+      onRegister() {
+        self.onRegister();
+      },
+
+      onUnregister() {
+        // no-op
+      },
+    };
+    swm.addListener(this._serviceWorkerListener);
+  }
+
+  uninit() {
+    if (defaultAssertHandler === this) {
+      defaultAssertHandler = null;
+    }
+
+    var obs = Services.obs;
+    obs.removeObserver(this._observer, "http-on-modify-request");
+    this._registerObservers._topics.splice(0).forEach(element => {
+      obs.removeObserver(this._registerObservers, element);
+    });
+    this._removeProcessCrashObservers();
+
+    let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
+      Ci.nsIServiceWorkerManager
+    );
+    swm.removeListener(this._serviceWorkerListener);
+  }
+
+  observe(aSubject, aTopic, aData) {
+    function addDumpIDToMessage(propertyName) {
+      try {
+        var id = aSubject.getPropertyAsAString(propertyName);
+      } catch (ex) {
+        id = null;
+      }
+      if (id) {
+        message.dumpIDs.push({ id, extension: "dmp" });
+        message.dumpIDs.push({ id, extension: "extra" });
+      }
+    }
+
+    switch (aTopic) {
+      case "http-on-modify-request":
+        if (aSubject instanceof Ci.nsIChannel) {
+          let uri = aSubject.URI.spec;
+          this.sendAsyncMessage("specialpowers-http-notify-request", { uri });
+        }
+        break;
+
+      case "plugin-crashed":
+      case "ipc:content-shutdown":
+        var message = { type: "crash-observed", dumpIDs: [] };
+        aSubject = aSubject.QueryInterface(Ci.nsIPropertyBag2);
+        if (aTopic == "plugin-crashed") {
+          addDumpIDToMessage("pluginDumpID");
+
+          let pluginID = aSubject.getPropertyAsAString("pluginDumpID");
+          let additionalMinidumps = aSubject.getPropertyAsACString(
+            "additionalMinidumps"
+          );
+          if (additionalMinidumps.length != 0) {
+            let dumpNames = additionalMinidumps.split(",");
+            for (let name of dumpNames) {
+              message.dumpIDs.push({
+                id: pluginID + "-" + name,
+                extension: "dmp",
+              });
+            }
+          }
+        } else {
+          // ipc:content-shutdown
+          if (!aSubject.hasKey("abnormal")) {
+            return; // This is a normal shutdown, ignore it
+          }
+
+          addDumpIDToMessage("dumpID");
+        }
+        this.sendAsyncMessage("SPProcessCrashService", message);
+        break;
+    }
+  }
+
+  _getCrashDumpDir() {
+    if (!this._crashDumpDir) {
+      this._crashDumpDir = Services.dirsvc.get("ProfD", Ci.nsIFile);
+      this._crashDumpDir.append("minidumps");
+    }
+    return this._crashDumpDir;
+  }
+
+  _getPendingCrashDumpDir() {
+    if (!this._pendingCrashDumpDir) {
+      this._pendingCrashDumpDir = Services.dirsvc.get("UAppData", Ci.nsIFile);
+      this._pendingCrashDumpDir.append("Crash Reports");
+      this._pendingCrashDumpDir.append("pending");
+    }
+    return this._pendingCrashDumpDir;
+  }
+
+  _deleteCrashDumpFiles(aFilenames) {
+    var crashDumpDir = this._getCrashDumpDir();
+    if (!crashDumpDir.exists()) {
+      return false;
+    }
+
+    var success = aFilenames.length != 0;
+    aFilenames.forEach(function(crashFilename) {
+      var file = crashDumpDir.clone();
+      file.append(crashFilename);
+      if (file.exists()) {
+        file.remove(false);
+      } else {
+        success = false;
+      }
+    });
+    return success;
+  }
+
+  _findCrashDumpFiles(aToIgnore) {
+    var crashDumpDir = this._getCrashDumpDir();
+    var entries = crashDumpDir.exists() && crashDumpDir.directoryEntries;
+    if (!entries) {
+      return [];
+    }
+
+    var crashDumpFiles = [];
+    while (entries.hasMoreElements()) {
+      var file = entries.nextFile;
+      var path = String(file.path);
+      if (path.match(/\.(dmp|extra)$/) && !aToIgnore[path]) {
+        crashDumpFiles.push(path);
+      }
+    }
+    return crashDumpFiles.concat();
+  }
+
+  _deletePendingCrashDumpFiles() {
+    var crashDumpDir = this._getPendingCrashDumpDir();
+    var removed = false;
+    if (crashDumpDir.exists()) {
+      let entries = crashDumpDir.directoryEntries;
+      while (entries.hasMoreElements()) {
+        let file = entries.nextFile;
+        if (file.isFile()) {
+          file.remove(false);
+          removed = true;
+        }
+      }
+    }
+    return removed;
+  }
+
+  _addProcessCrashObservers() {
+    if (this._processCrashObserversRegistered) {
+      return;
+    }
+
+    Services.obs.addObserver(this._observer, "plugin-crashed");
+    Services.obs.addObserver(this._observer, "ipc:content-shutdown");
+    this._processCrashObserversRegistered = true;
+  }
+
+  _removeProcessCrashObservers() {
+    if (!this._processCrashObserversRegistered) {
+      return;
+    }
+
+    Services.obs.removeObserver(this._observer, "plugin-crashed");
+    Services.obs.removeObserver(this._observer, "ipc:content-shutdown");
+    this._processCrashObserversRegistered = false;
+  }
+
+  onRegister() {
+    this.sendAsyncMessage("SPServiceWorkerRegistered", { registered: true });
+  }
+
+  _getURI(url) {
+    return Services.io.newURI(url);
+  }
+  _notifyCategoryAndObservers(subject, topic, data) {
+    const serviceMarker = "service,";
+
+    // First create observers from the category manager.
+
+    let observers = [];
+
+    for (let { value: contractID } of Services.catMan.enumerateCategory(
+      topic
+    )) {
+      let factoryFunction;
+      if (contractID.substring(0, serviceMarker.length) == serviceMarker) {
+        contractID = contractID.substring(serviceMarker.length);
+        factoryFunction = "getService";
+      } else {
+        factoryFunction = "createInstance";
+      }
+
+      try {
+        let handler = Cc[contractID][factoryFunction]();
+        if (handler) {
+          let observer = handler.QueryInterface(Ci.nsIObserver);
+          observers.push(observer);
+        }
+      } catch (e) {}
+    }
+
+    // Next enumerate the registered observers.
+    for (let observer of Services.obs.enumerateObservers(topic)) {
+      if (observer instanceof Ci.nsIObserver && !observers.includes(observer)) {
+        observers.push(observer);
+      }
+    }
+
+    observers.forEach(function(observer) {
+      try {
+        observer.observe(subject, topic, data);
+      } catch (e) {}
+    });
+  }
+
+  /*
+    Iterate through one atomic set of pref actions and perform sets/clears as appropriate.
+    All actions performed must modify the relevant pref.
+  */
+  _applyPrefs(actions) {
+    for (let pref of actions) {
+      if (pref.action == "set") {
+        this._setPref(pref.name, pref.type, pref.value, pref.iid);
+      } else if (pref.action == "clear") {
+        Services.prefs.clearUserPref(pref.name);
+      }
+    }
+  }
+
+  /**
+   * Take in a list of pref changes to make, pushes their current values
+   * onto the restore stack, and makes the changes.  When the test
+   * finishes, these changes are reverted.
+   *
+   * |inPrefs| must be an object with up to two properties: "set" and "clear".
+   * pushPrefEnv will set prefs as indicated in |inPrefs.set| and will unset
+   * the prefs indicated in |inPrefs.clear|.
+   *
+   * For example, you might pass |inPrefs| as:
+   *
+   *  inPrefs = {'set': [['foo.bar', 2], ['magic.pref', 'baz']],
+   *             'clear': [['clear.this'], ['also.this']] };
+   *
+   * Notice that |set| and |clear| are both an array of arrays.  In |set|, each
+   * of the inner arrays must have the form [pref_name, value] or [pref_name,
+   * value, iid].  (The latter form is used for prefs with "complex" values.)
+   *
+   * In |clear|, each inner array should have the form [pref_name].
+   *
+   * If you set the same pref more than once (or both set and clear a pref),
+   * the behavior of this method is undefined.
+   */
+  pushPrefEnv(inPrefs) {
+    return doPrefEnvOp(() => {
+      let pendingActions = [];
+      let cleanupActions = [];
+
+      for (let [action, prefs] of Object.entries(inPrefs)) {
+        for (let pref of prefs) {
+          let name = pref[0];
+          let value = null;
+          let iid = null;
+          let type = PREF_TYPES[Services.prefs.getPrefType(name)];
+          let originalValue = null;
+
+          if (pref.length == 3) {
+            value = pref[1];
+            iid = pref[2];
+          } else if (pref.length == 2) {
+            value = pref[1];
+          }
+
+          /* If pref is not found or invalid it doesn't exist. */
+          if (type !== "INVALID") {
+            if (
+              (Services.prefs.prefHasUserValue(name) && action == "clear") ||
+              action == "set"
+            ) {
+              originalValue = this._getPref(name, type);
+            }
+          } else if (action == "set") {
+            /* name doesn't exist, so 'clear' is pointless */
+            if (iid) {
+              type = "COMPLEX";
+            }
+          }
+
+          if (type === "INVALID") {
+            type = PREF_TYPES[typeof value];
+          }
+          if (type === "INVALID") {
+            throw new Error("Unexpected preference type");
+          }
+
+          pendingActions.push({ action, type, name, value, iid });
+
+          /* Push original preference value or clear into cleanup array */
+          var cleanupTodo = { type, name, value: originalValue, iid };
+          if (originalValue == null) {
+            cleanupTodo.action = "clear";
+          } else {
+            cleanupTodo.action = "set";
+          }
+          cleanupActions.push(cleanupTodo);
+        }
+      }
+
+      prefUndoStack.push(cleanupActions);
+      this._applyPrefs(pendingActions);
+    });
+  }
+
+  async popPrefEnv() {
+    return doPrefEnvOp(() => {
+      let env = prefUndoStack.pop();
+      if (env) {
+        this._applyPrefs(env);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  flushPrefEnv() {
+    while (prefUndoStack.length) {
+      this.popPrefEnv();
+    }
+  }
+
+  _setPref(name, type, value, iid) {
+    switch (type) {
+      case "BOOL":
+        return Services.prefs.setBoolPref(name, value);
+      case "INT":
+        return Services.prefs.setIntPref(name, value);
+      case "CHAR":
+        return Services.prefs.setCharPref(name, value);
+      case "COMPLEX":
+        return Services.prefs.setComplexValue(name, iid, value);
+    }
+    throw new Error(`Unexpected preference type: ${type}`);
+  }
+
+  _getPref(name, type, defaultValue, iid) {
+    switch (type) {
+      case "BOOL":
+        if (defaultValue !== undefined) {
+          return Services.prefs.getBoolPref(name, defaultValue);
+        }
+        return Services.prefs.getBoolPref(name);
+      case "INT":
+        if (defaultValue !== undefined) {
+          return Services.prefs.getIntPref(name, defaultValue);
+        }
+        return Services.prefs.getIntPref(name);
+      case "CHAR":
+        if (defaultValue !== undefined) {
+          return Services.prefs.getCharPref(name, defaultValue);
+        }
+        return Services.prefs.getCharPref(name);
+      case "COMPLEX":
+        return Services.prefs.getComplexValue(name, iid);
+    }
+    throw new Error(`Unexpected preference type: ${type}`);
+  }
+
+  _toggleMuteAudio(aMuted) {
+    let browser = this.browsingContext.top.embedderElement;
+    if (aMuted) {
+      browser.mute();
+    } else {
+      browser.unmute();
+    }
+  }
+
+  _permOp(perm) {
+    switch (perm.op) {
+      case "add":
+        Services.perms.addFromPrincipal(
+          perm.principal,
+          perm.type,
+          perm.permission,
+          perm.expireType,
+          perm.expireTime
+        );
+        break;
+      case "remove":
+        Services.perms.removeFromPrincipal(perm.principal, perm.type);
+        break;
+      default:
+        throw new Error(`Unexpected permission op: ${perm.op}`);
+    }
+  }
+
+  pushPermissions(inPermissions) {
+    let pendingPermissions = [];
+    let cleanupPermissions = [];
+
+    for (let permission of inPermissions) {
+      let { principal } = permission;
+      if (principal.isSystemPrincipal) {
+        continue;
+      }
+
+      let originalValue = Services.perms.testPermissionFromPrincipal(
+        principal,
+        permission.type
+      );
+
+      let perm = permission.allow;
+      if (typeof perm === "boolean") {
+        perm = Ci.nsIPermissionManager[perm ? "ALLOW_ACTION" : "DENY_ACTION"];
+      }
+
+      if (permission.remove) {
+        perm = Ci.nsIPermissionManager.UNKNOWN_ACTION;
+      }
+
+      if (originalValue == perm) {
+        continue;
+      }
+
+      let todo = {
+        op: "add",
+        type: permission.type,
+        permission: perm,
+        value: perm,
+        principal,
+        expireType:
+          typeof permission.expireType === "number" ? permission.expireType : 0, // default: EXPIRE_NEVER
+        expireTime:
+          typeof permission.expireTime === "number" ? permission.expireTime : 0,
+      };
+
+      var cleanupTodo = Object.assign({}, todo);
+
+      if (permission.remove) {
+        todo.op = "remove";
+      }
+
+      pendingPermissions.push(todo);
+
+      if (originalValue == Ci.nsIPermissionManager.UNKNOWN_ACTION) {
+        cleanupTodo.op = "remove";
+      } else {
+        cleanupTodo.value = originalValue;
+        cleanupTodo.permission = originalValue;
+      }
+      cleanupPermissions.push(cleanupTodo);
+    }
+
+    permissionUndoStack.push(cleanupPermissions);
+
+    for (let perm of pendingPermissions) {
+      this._permOp(perm);
+    }
+  }
+
+  popPermissions() {
+    if (permissionUndoStack.length) {
+      for (let perm of permissionUndoStack.pop()) {
+        this._permOp(perm);
+      }
+    }
+  }
+
+  flushPermissions() {
+    while (permissionUndoStack.length) {
+      this.popPermissions();
+    }
+  }
+
+  _spawnChrome(task, args, caller, imports) {
+    let sb = new SpecialPowersSandbox(
+      null,
+      data => {
+        this.sendAsyncMessage("Assert", data);
+      },
+      { imports }
+    );
+
+    for (let [global, prop] of Object.entries({
+      windowGlobalParent: "manager",
+      browsingContext: "browsingContext",
+    })) {
+      Object.defineProperty(sb.sandbox, global, {
+        get: () => {
+          return this[prop];
+        },
+        enumerable: true,
+      });
+    }
+
+    return sb.execute(task, args, caller);
+  }
+
+  /**
+   * messageManager callback function
+   * This will get requests from our API in the window and process them in chrome for it
+   **/
+  // eslint-disable-next-line complexity
+  receiveMessage(aMessage) {
+    ChromeUtils.addProfilerMarker(
+      "SpecialPowers",
+      { category: "Test" },
+      aMessage.name
+    );
+
+    // We explicitly return values in the below code so that this function
+    // doesn't trigger a flurry of warnings about "does not always return
+    // a value".
+    switch (aMessage.name) {
+      case "SPToggleMuteAudio":
+        return this._toggleMuteAudio(aMessage.data.mute);
+
+      case "Ping":
+        return undefined;
+
+      case "SpecialPowers.Quit":
+        if (
+          !AppConstants.RELEASE_OR_BETA &&
+          !AppConstants.DEBUG &&
+          !AppConstants.MOZ_CODE_COVERAGE &&
+          !AppConstants.ASAN &&
+          !AppConstants.TSAN
+        ) {
+          Cu.exitIfInAutomation();
+        } else {
+          Services.startup.quit(Ci.nsIAppStartup.eForceQuit);
+        }
+        return undefined;
+
+      case "SpecialPowers.Focus":
+        if (this.manager.rootFrameLoader) {
+          this.manager.rootFrameLoader.ownerElement.focus();
+        }
+        return undefined;
+
+      case "SpecialPowers.CreateFiles":
+        return (async () => {
+          let filePaths = [];
+          if (!this._createdFiles) {
+            this._createdFiles = [];
+          }
+          let createdFiles = this._createdFiles;
+
+          let promises = [];
+          aMessage.data.forEach(function(request) {
+            const filePerms = 0o666;
+            let testFile = Services.dirsvc.get("ProfD", Ci.nsIFile);
+            if (request.name) {
+              testFile.appendRelativePath(request.name);
+            } else {
+              testFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, filePerms);
+            }
+            let outStream = Cc[
+              "@mozilla.org/network/file-output-stream;1"
+            ].createInstance(Ci.nsIFileOutputStream);
+            outStream.init(
+              testFile,
+              0x02 | 0x08 | 0x20, // PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE
+              filePerms,
+              0
+            );
+            if (request.data) {
+              outStream.write(request.data, request.data.length);
+            }
+            outStream.close();
+            promises.push(
+              File.createFromFileName(testFile.path, request.options).then(
+                function(file) {
+                  filePaths.push(file);
+                }
+              )
+            );
+            createdFiles.push(testFile);
+          });
+
+          await Promise.all(promises);
+          return filePaths;
+        })().catch(e => {
+          Cu.reportError(e);
+          return Promise.reject(String(e));
+        });
+
+      case "SpecialPowers.RemoveFiles":
+        if (this._createdFiles) {
+          this._createdFiles.forEach(function(testFile) {
+            try {
+              testFile.remove(false);
+            } catch (e) {}
+          });
+          this._createdFiles = null;
+        }
+        return undefined;
+
+      case "Wakeup":
+        return undefined;
+
+      case "PushPrefEnv":
+        return this.pushPrefEnv(aMessage.data);
+
+      case "PopPrefEnv":
+        return this.popPrefEnv();
+
+      case "FlushPrefEnv":
+        return this.flushPrefEnv();
+
+      case "PushPermissions":
+        return this.pushPermissions(aMessage.data);
+
+      case "PopPermissions":
+        return this.popPermissions();
+
+      case "FlushPermissions":
+        return this.flushPermissions();
+
+      case "SPPrefService": {
+        let prefs = Services.prefs;
+        let prefType = aMessage.json.prefType.toUpperCase();
+        let { prefName, prefValue, iid, defaultValue } = aMessage.json;
+
+        if (aMessage.json.op == "get") {
+          if (!prefName || !prefType) {
+            throw new SpecialPowersError(
+              "Invalid parameters for get in SPPrefService"
+            );
+          }
+
+          // return null if the pref doesn't exist
+          if (
+            defaultValue === undefined &&
+            prefs.getPrefType(prefName) == prefs.PREF_INVALID
+          ) {
+            return null;
+          }
+          return this._getPref(prefName, prefType, defaultValue, iid);
+        } else if (aMessage.json.op == "set") {
+          if (!prefName || !prefType || prefValue === undefined) {
+            throw new SpecialPowersError(
+              "Invalid parameters for set in SPPrefService"
+            );
+          }
+
+          return this._setPref(prefName, prefType, prefValue, iid);
+        } else if (aMessage.json.op == "clear") {
+          if (!prefName) {
+            throw new SpecialPowersError(
+              "Invalid parameters for clear in SPPrefService"
+            );
+          }
+
+          prefs.clearUserPref(prefName);
+        } else {
+          throw new SpecialPowersError("Invalid operation for SPPrefService");
+        }
+
+        return undefined; // See comment at the beginning of this function.
+      }
+
+      case "SPProcessCrashService": {
+        switch (aMessage.json.op) {
+          case "register-observer":
+            this._addProcessCrashObservers();
+            break;
+          case "unregister-observer":
+            this._removeProcessCrashObservers();
+            break;
+          case "delete-crash-dump-files":
+            return this._deleteCrashDumpFiles(aMessage.json.filenames);
+          case "find-crash-dump-files":
+            return this._findCrashDumpFiles(
+              aMessage.json.crashDumpFilesToIgnore
+            );
+          case "delete-pending-crash-dump-files":
+            return this._deletePendingCrashDumpFiles();
+          default:
+            throw new SpecialPowersError(
+              "Invalid operation for SPProcessCrashService"
+            );
+        }
+        return undefined; // See comment at the beginning of this function.
+      }
+
+      case "SPProcessCrashManagerWait": {
+        let promises = aMessage.json.crashIds.map(crashId => {
+          return Services.crashmanager.ensureCrashIsPresent(crashId);
+        });
+        return Promise.all(promises);
+      }
+
+      case "SPPermissionManager": {
+        let msg = aMessage.data;
+        switch (msg.op) {
+          case "add":
+          case "remove":
+            this._permOp(msg);
+            break;
+          case "has":
+            let hasPerm = Services.perms.testPermissionFromPrincipal(
+              msg.principal,
+              msg.type
+            );
+            return hasPerm == Ci.nsIPermissionManager.ALLOW_ACTION;
+          case "test":
+            let testPerm = Services.perms.testPermissionFromPrincipal(
+              msg.principal,
+              msg.type
+            );
+            return testPerm == msg.value;
+          default:
+            throw new SpecialPowersError(
+              "Invalid operation for SPPermissionManager"
+            );
+        }
+        return undefined; // See comment at the beginning of this function.
+      }
+
+      case "SPSetTestPluginEnabledState": {
+        var plugin = getTestPlugin(aMessage.data.pluginName);
+        if (!plugin) {
+          return undefined;
+        }
+        var oldEnabledState = plugin.enabledState;
+        plugin.enabledState = aMessage.data.newEnabledState;
+        return oldEnabledState;
+      }
+
+      case "SPObserverService": {
+        let topic = aMessage.json.observerTopic;
+        switch (aMessage.json.op) {
+          case "notify":
+            let data = aMessage.json.observerData;
+            Services.obs.notifyObservers(null, topic, data);
+            break;
+          case "add":
+            this._registerObservers._add(topic);
+            break;
+          default:
+            throw new SpecialPowersError(
+              "Invalid operation for SPObserverervice"
+            );
+        }
+        return undefined; // See comment at the beginning of this function.
+      }
+
+      case "SPLoadChromeScript": {
+        let id = aMessage.json.id;
+        let scriptName;
+
+        let jsScript = aMessage.json.function.body;
+        if (aMessage.json.url) {
+          scriptName = aMessage.json.url;
+        } else if (aMessage.json.function) {
+          scriptName =
+            aMessage.json.function.name ||
+            "<loadChromeScript anonymous function>";
+        } else {
+          throw new SpecialPowersError("SPLoadChromeScript: Invalid script");
+        }
+
+        // Setup a chrome sandbox that has access to sendAsyncMessage
+        // and {add,remove}MessageListener in order to communicate with
+        // the mochitest.
+        let sb = new SpecialPowersSandbox(
+          scriptName,
+          data => {
+            this.sendAsyncMessage("Assert", data);
+          },
+          aMessage.data
+        );
+
+        Object.assign(sb.sandbox, {
+          createWindowlessBrowser,
+          sendAsyncMessage: (name, message) => {
+            this.sendAsyncMessage("SPChromeScriptMessage", {
+              id,
+              name,
+              message,
+            });
+          },
+          addMessageListener: (name, listener) => {
+            this._chromeScriptListeners.push({ id, name, listener });
+          },
+          removeMessageListener: (name, listener) => {
+            let index = this._chromeScriptListeners.findIndex(function(obj) {
+              return (
+                obj.id == id && obj.name == name && obj.listener == listener
+              );
+            });
+            if (index >= 0) {
+              this._chromeScriptListeners.splice(index, 1);
+            }
+          },
+          actorParent: this.manager,
+        });
+
+        // Evaluate the chrome script
+        try {
+          Cu.evalInSandbox(jsScript, sb.sandbox, "1.8", scriptName, 1);
+        } catch (e) {
+          throw new SpecialPowersError(
+            "Error while executing chrome script '" +
+              scriptName +
+              "':\n" +
+              e +
+              "\n" +
+              e.fileName +
+              ":" +
+              e.lineNumber
+          );
+        }
+        return undefined; // See comment at the beginning of this function.
+      }
+
+      case "SPChromeScriptMessage": {
+        let id = aMessage.json.id;
+        let name = aMessage.json.name;
+        let message = aMessage.json.message;
+        let result;
+        for (let listener of this._chromeScriptListeners) {
+          if (listener.name == name && listener.id == id) {
+            result = listener.listener(message);
+          }
+        }
+        return result;
+      }
+
+      case "SPImportInMainProcess": {
+        var message = { hadError: false, errorMessage: null };
+        try {
+          ChromeUtils.import(aMessage.data);
+        } catch (e) {
+          message.hadError = true;
+          message.errorMessage = e.toString();
+        }
+        return message;
+      }
+
+      case "SPCleanUpSTSData": {
+        let origin = aMessage.data.origin;
+        let flags = aMessage.data.flags;
+        let uri = Services.io.newURI(origin);
+        let sss = Cc["@mozilla.org/ssservice;1"].getService(
+          Ci.nsISiteSecurityService
+        );
+        sss.resetState(Ci.nsISiteSecurityService.HEADER_HSTS, uri, flags);
+        return undefined;
+      }
+
+      case "SPRequestDumpCoverageCounters": {
+        return PerTestCoverageUtils.afterTest();
+      }
+
+      case "SPRequestResetCoverageCounters": {
+        return PerTestCoverageUtils.beforeTest();
+      }
+
+      case "SPCheckServiceWorkers": {
+        let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
+          Ci.nsIServiceWorkerManager
+        );
+        let regs = swm.getAllRegistrations();
+
+        // XXX This code is shared with specialpowers.js.
+        let workers = new Array(regs.length);
+        for (let i = 0; i < regs.length; ++i) {
+          let { scope, scriptSpec } = regs.queryElementAt(
+            i,
+            Ci.nsIServiceWorkerRegistrationInfo
+          );
+          workers[i] = { scope, scriptSpec };
+        }
+        return { workers };
+      }
+
+      case "SPLoadExtension": {
+        let id = aMessage.data.id;
+        let ext = aMessage.data.ext;
+        let extension = ExtensionTestCommon.generate(ext);
+
+        let resultListener = (...args) => {
+          this.sendAsyncMessage("SPExtensionMessage", {
+            id,
+            type: "testResult",
+            args,
+          });
+        };
+
+        let messageListener = (...args) => {
+          args.shift();
+          this.sendAsyncMessage("SPExtensionMessage", {
+            id,
+            type: "testMessage",
+            args,
+          });
+        };
+
+        // Register pass/fail handlers.
+        extension.on("test-result", resultListener);
+        extension.on("test-eq", resultListener);
+        extension.on("test-log", resultListener);
+        extension.on("test-done", resultListener);
+
+        extension.on("test-message", messageListener);
+
+        this._extensions.set(id, extension);
+        return undefined;
+      }
+
+      case "SPStartupExtension": {
+        let id = aMessage.data.id;
+        // This is either an Extension, or (if useAddonManager is set) a MockExtension.
+        let extension = this._extensions.get(id);
+        extension.on("startup", (eventName, ext) => {
+          if (AppConstants.platform === "android") {
+            // We need a way to notify the embedding layer that a new extension
+            // has been installed, so that the java layer can be updated too.
+            Services.obs.notifyObservers(null, "testing-installed-addon", id);
+          }
+          // ext is always the "real" Extension object, even when "extension"
+          // is a MockExtension.
+          this.sendAsyncMessage("SPExtensionMessage", {
+            id,
+            type: "extensionSetId",
+            args: [ext.id, ext.uuid],
+          });
+        });
+
+        // Make sure the extension passes the packaging checks when
+        // they're run on a bare archive rather than a running instance,
+        // as the add-on manager runs them.
+        let extensionData = new ExtensionData(extension.rootURI);
+        return extensionData
+          .loadManifest()
+          .then(
+            () => {
+              return extensionData.initAllLocales().then(() => {
+                if (extensionData.errors.length) {
+                  return Promise.reject("Extension contains packaging errors");
+                }
+                return undefined;
+              });
+            },
+            () => {
+              // loadManifest() will throw if we're loading an embedded
+              // extension, so don't worry about locale errors in that
+              // case.
+            }
+          )
+          .then(async () => {
+            // browser tests do not call startup in ExtensionXPCShellUtils or MockExtension,
+            // in that case we have an ID here and we need to set the override.
+            if (extension.id) {
+              await ExtensionTestCommon.setIncognitoOverride(extension);
+            }
+            return extension.startup().then(
+              () => {},
+              e => {
+                dump(`Extension startup failed: ${e}\n${e.stack}`);
+                throw e;
+              }
+            );
+          });
+      }
+
+      case "SPExtensionMessage": {
+        let id = aMessage.data.id;
+        let extension = this._extensions.get(id);
+        extension.testMessage(...aMessage.data.args);
+        return undefined;
+      }
+
+      case "SPExtensionGrantActiveTab": {
+        let { id, tabId } = aMessage.data;
+        let { tabManager } = this._extensions.get(id);
+        tabManager.addActiveTabPermission(tabManager.get(tabId).nativeTab);
+        return undefined;
+      }
+
+      case "SPUnloadExtension": {
+        let id = aMessage.data.id;
+        let extension = this._extensions.get(id);
+        this._extensions.delete(id);
+        return extension.shutdown().then(() => {
+          return extension._uninstallPromise;
+        });
+      }
+
+      case "SetAsDefaultAssertHandler": {
+        defaultAssertHandler = this;
+        return undefined;
+      }
+
+      case "Spawn": {
+        let {
+          browsingContext,
+          task,
+          args,
+          caller,
+          hasHarness,
+          imports,
+        } = aMessage.data;
+
+        let spParent = browsingContext.currentWindowGlobal.getActor(
+          "SpecialPowers"
+        );
+
+        let taskId = nextTaskID++;
+        if (hasHarness) {
+          spParent._taskActors.set(taskId, this);
+        }
+
+        return spParent
+          .sendQuery("Spawn", { task, args, caller, taskId, imports })
+          .finally(() => spParent._taskActors.delete(taskId));
+      }
+
+      case "SpawnChrome": {
+        let { task, args, caller, imports } = aMessage.data;
+
+        return this._spawnChrome(task, args, caller, imports);
+      }
+
+      case "Snapshot": {
+        let { browsingContext, rect, background } = aMessage.data;
+
+        return browsingContext.currentWindowGlobal
+          .drawSnapshot(rect, 1.0, background)
+          .then(async image => {
+            let hiddenFrame = new HiddenFrame();
+            let win = await hiddenFrame.get();
+
+            let canvas = win.document.createElement("canvas");
+            canvas.width = image.width;
+            canvas.height = image.height;
+
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(image, 0, 0);
+
+            let data = ctx.getImageData(0, 0, image.width, image.height);
+            hiddenFrame.destroy();
+            return data;
+          });
+      }
+
+      case "SecurityState": {
+        let { browsingContext } = aMessage.data;
+        return browsingContext.secureBrowserUI.state;
+      }
+
+      case "ProxiedAssert": {
+        let { taskId, data } = aMessage.data;
+
+        let actor = this._taskActors.get(taskId) || defaultAssertHandler;
+        actor.sendAsyncMessage("Assert", data);
+
+        return undefined;
+      }
+
+      case "SPRemoveAllServiceWorkers": {
+        return ServiceWorkerCleanUp.removeAll();
+      }
+
+      case "SPRemoveServiceWorkerDataForExampleDomain": {
+        return ServiceWorkerCleanUp.removeFromHost("example.com");
+      }
+
+      case "SPGenerateMediaControlKeyTestEvent": {
+        // eslint-disable-next-line no-undef
+        MediaControlService.generateMediaControlKey(aMessage.data.event);
+        return undefined;
+      }
+
+      default:
+        throw new SpecialPowersError(
+          `Unrecognized Special Powers API: ${aMessage.name}`
+        );
+    }
+    // This should be unreachable. If it ever becomes reachable, ESLint
+    // will produce an error about inconsistent return values.
+  }
+}