Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 1023 insertions, 0 deletions

diff --git a/devtools/shared/DevToolsUtils.js b/devtools/shared/DevToolsUtils.js
new file mode 100644
index 0000000000..2a9979b456
--- /dev/null
+++ b/devtools/shared/DevToolsUtils.js
@@ -0,0 +1,1023 @@
+/* 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/. */
+
+/* globals setImmediate, rpc */
+
+"use strict";
+
+/* General utilities used throughout devtools. */
+
+var flags = require("resource://devtools/shared/flags.js");
+var {
+  getStack,
+  callFunctionWithAsyncStack,
+} = require("resource://devtools/shared/platform/stack.js");
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+  NetworkHelper:
+    "resource://devtools/shared/network-observer/NetworkHelper.sys.mjs",
+});
+
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "ObjectUtils",
+  "resource://gre/modules/ObjectUtils.jsm"
+);
+
+// Native getters which are considered to be side effect free.
+ChromeUtils.defineLazyGetter(lazy, "sideEffectFreeGetters", () => {
+  const {
+    getters,
+  } = require("resource://devtools/server/actors/webconsole/eager-ecma-allowlist.js");
+
+  const map = new Map();
+  for (const n of getters) {
+    if (!map.has(n.name)) {
+      map.set(n.name, []);
+    }
+    map.get(n.name).push(n);
+  }
+
+  return map;
+});
+
+// Using this name lets the eslint plugin know about lazy defines in
+// this file.
+var DevToolsUtils = exports;
+
+// Re-export the thread-safe utils.
+const ThreadSafeDevToolsUtils = require("resource://devtools/shared/ThreadSafeDevToolsUtils.js");
+for (const key of Object.keys(ThreadSafeDevToolsUtils)) {
+  exports[key] = ThreadSafeDevToolsUtils[key];
+}
+
+/**
+ * Waits for the next tick in the event loop to execute a callback.
+ */
+exports.executeSoon = function (fn) {
+  if (isWorker) {
+    setImmediate(fn);
+  } else {
+    let executor;
+    // Only enable async stack reporting when DEBUG_JS_MODULES is set
+    // (customized local builds) to avoid a performance penalty.
+    if (AppConstants.DEBUG_JS_MODULES || flags.testing) {
+      const stack = getStack();
+      executor = () => {
+        callFunctionWithAsyncStack(fn, stack, "DevToolsUtils.executeSoon");
+      };
+    } else {
+      executor = fn;
+    }
+    Services.tm.dispatchToMainThread({
+      run: exports.makeInfallible(executor),
+    });
+  }
+};
+
+/**
+ * Similar to executeSoon, but enters microtask before executing the callback
+ * if this is called on the main thread.
+ */
+exports.executeSoonWithMicroTask = function (fn) {
+  if (isWorker) {
+    setImmediate(fn);
+  } else {
+    let executor;
+    // Only enable async stack reporting when DEBUG_JS_MODULES is set
+    // (customized local builds) to avoid a performance penalty.
+    if (AppConstants.DEBUG_JS_MODULES || flags.testing) {
+      const stack = getStack();
+      executor = () => {
+        callFunctionWithAsyncStack(
+          fn,
+          stack,
+          "DevToolsUtils.executeSoonWithMicroTask"
+        );
+      };
+    } else {
+      executor = fn;
+    }
+    Services.tm.dispatchToMainThreadWithMicroTask({
+      run: exports.makeInfallible(executor),
+    });
+  }
+};
+
+/**
+ * Waits for the next tick in the event loop.
+ *
+ * @return Promise
+ *         A promise that is resolved after the next tick in the event loop.
+ */
+exports.waitForTick = function () {
+  return new Promise(resolve => {
+    exports.executeSoon(resolve);
+  });
+};
+
+/**
+ * Waits for the specified amount of time to pass.
+ *
+ * @param number delay
+ *        The amount of time to wait, in milliseconds.
+ * @return Promise
+ *         A promise that is resolved after the specified amount of time passes.
+ */
+exports.waitForTime = function (delay) {
+  return new Promise(resolve => setTimeout(resolve, delay));
+};
+
+/**
+ * Like XPCOMUtils.defineLazyGetter, but with a |this| sensitive getter that
+ * allows the lazy getter to be defined on a prototype and work correctly with
+ * instances.
+ *
+ * @param Object object
+ *        The prototype object to define the lazy getter on.
+ * @param String key
+ *        The key to define the lazy getter on.
+ * @param Function callback
+ *        The callback that will be called to determine the value. Will be
+ *        called with the |this| value of the current instance.
+ */
+exports.defineLazyPrototypeGetter = function (object, key, callback) {
+  Object.defineProperty(object, key, {
+    configurable: true,
+    get() {
+      const value = callback.call(this);
+
+      Object.defineProperty(this, key, {
+        configurable: true,
+        writable: true,
+        value,
+      });
+
+      return value;
+    },
+  });
+};
+
+/**
+ * Safely get the property value from a Debugger.Object for a given key. Walks
+ * the prototype chain until the property is found.
+ *
+ * @param {Debugger.Object} object
+ *        The Debugger.Object to get the value from.
+ * @param {String} key
+ *        The key to look for.
+ * @param {Boolean} invokeUnsafeGetter (defaults to false).
+ *        Optional boolean to indicate if the function should execute unsafe getter
+ *        in order to retrieve its result's properties.
+ *        ⚠️ This should be set to true *ONLY* on user action as it may cause side-effects
+ *        in the content page ⚠️
+ * @return Any
+ */
+exports.getProperty = function (object, key, invokeUnsafeGetters = false) {
+  const root = object;
+  while (object && exports.isSafeDebuggerObject(object)) {
+    let desc;
+    try {
+      desc = object.getOwnPropertyDescriptor(key);
+    } catch (e) {
+      // The above can throw when the debuggee does not subsume the object's
+      // compartment, or for some WrappedNatives like Cu.Sandbox.
+      return undefined;
+    }
+    if (desc) {
+      if ("value" in desc) {
+        return desc.value;
+      }
+      // Call the getter if it's safe.
+      if (exports.hasSafeGetter(desc) || invokeUnsafeGetters === true) {
+        try {
+          return desc.get.call(root).return;
+        } catch (e) {
+          // If anything goes wrong report the error and return undefined.
+          exports.reportException("getProperty", e);
+        }
+      }
+      return undefined;
+    }
+    object = object.proto;
+  }
+  return undefined;
+};
+
+/**
+ * Removes all the non-opaque security wrappers of a debuggee object.
+ *
+ * @param obj Debugger.Object
+ *        The debuggee object to be unwrapped.
+ * @return Debugger.Object|null|undefined
+ *      - If the object has no wrapper, the same `obj` is returned. Note DeadObject
+ *        objects belong to this case.
+ *      - Otherwise, if the debuggee doesn't subsume object's compartment, returns `null`.
+ *      - Otherwise, if the object belongs to an invisible-to-debugger compartment,
+ *        returns `undefined`.
+ *      - Otherwise, returns the unwrapped object.
+ */
+exports.unwrap = function unwrap(obj) {
+  // Check if `obj` has an opaque wrapper.
+  if (obj.class === "Opaque") {
+    return obj;
+  }
+
+  // Attempt to unwrap via `obj.unwrap()`. Note that:
+  // - This will return `null` if the debuggee does not subsume object's compartment.
+  // - This will throw if the object belongs to an invisible-to-debugger compartment.
+  // - This will return `obj` if there is no wrapper.
+  let unwrapped;
+  try {
+    unwrapped = obj.unwrap();
+  } catch (err) {
+    return undefined;
+  }
+
+  // Check if further unwrapping is not possible.
+  if (!unwrapped || unwrapped === obj) {
+    return unwrapped;
+  }
+
+  // Recursively remove additional security wrappers.
+  return unwrap(unwrapped);
+};
+
+/**
+ * Checks whether a debuggee object is safe. Unsafe objects may run proxy traps or throw
+ * when using `proto`, `isExtensible`, `isFrozen` or `isSealed`. Note that safe objects
+ * may still throw when calling `getOwnPropertyNames`, `getOwnPropertyDescriptor`, etc.
+ * Also note DeadObject objects are considered safe.
+ *
+ * @param obj Debugger.Object
+ *        The debuggee object to be checked.
+ * @return boolean
+ */
+exports.isSafeDebuggerObject = function (obj) {
+  const unwrapped = exports.unwrap(obj);
+
+  // Objects belonging to an invisible-to-debugger compartment might be proxies,
+  // so just in case consider them unsafe.
+  if (unwrapped === undefined) {
+    return false;
+  }
+
+  // If the debuggee does not subsume the object's compartment, most properties won't
+  // be accessible. Cross-origin Window and Location objects might expose some, though.
+  // Therefore, it must be considered safe. Note that proxy objects have fully opaque
+  // security wrappers, so proxy traps won't run in this case.
+  if (unwrapped === null) {
+    return true;
+  }
+
+  // Proxy objects can run traps when accessed. `isProxy` getter is called on `unwrapped`
+  // instead of on `obj` in order to detect proxies behind transparent wrappers.
+  if (unwrapped.isProxy) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Determines if a descriptor has a getter which doesn't call into JavaScript.
+ *
+ * @param Object desc
+ *        The descriptor to check for a safe getter.
+ * @return Boolean
+ *         Whether a safe getter was found.
+ */
+exports.hasSafeGetter = function (desc) {
+  // Scripted functions that are CCWs will not appear scripted until after
+  // unwrapping.
+  let fn = desc.get;
+  fn = fn && exports.unwrap(fn);
+  if (!fn) {
+    return false;
+  }
+  if (!fn.callable || fn.class !== "Function") {
+    return false;
+  }
+  if (fn.script !== undefined) {
+    // This is scripted function.
+    return false;
+  }
+
+  // This is a getter with native function.
+
+  // We assume all DOM getters have no major side effect, and they are
+  // eagerly-evaluateable.
+  //
+  // JitInfo is used only by methods/accessors in WebIDL, and being
+  // "a getter with JitInfo" can be used as a condition to check if given
+  // function is DOM getter.
+  //
+  // This includes privileged interfaces in addition to standard web APIs.
+  if (fn.isNativeGetterWithJitInfo()) {
+    return true;
+  }
+
+  // Apply explicit allowlist.
+  const natives = lazy.sideEffectFreeGetters.get(fn.name);
+  return natives && natives.some(n => fn.isSameNative(n));
+};
+
+/**
+ * Check that the property value from a Debugger.Object for a given key is an unsafe
+ * getter or not. Walks the prototype chain until the property is found.
+ *
+ * @param {Debugger.Object} object
+ *        The Debugger.Object to check on.
+ * @param {String} key
+ *        The key to look for.
+ * @param {Boolean} invokeUnsafeGetter (defaults to false).
+ *        Optional boolean to indicate if the function should execute unsafe getter
+ *        in order to retrieve its result's properties.
+ * @return Boolean
+ */
+exports.isUnsafeGetter = function (object, key) {
+  while (object && exports.isSafeDebuggerObject(object)) {
+    let desc;
+    try {
+      desc = object.getOwnPropertyDescriptor(key);
+    } catch (e) {
+      // The above can throw when the debuggee does not subsume the object's
+      // compartment, or for some WrappedNatives like Cu.Sandbox.
+      return false;
+    }
+    if (desc) {
+      if (Object.getOwnPropertyNames(desc).includes("get")) {
+        return !exports.hasSafeGetter(desc);
+      }
+    }
+    object = object.proto;
+  }
+
+  return false;
+};
+
+/**
+ * Check if it is safe to read properties and execute methods from the given JS
+ * object. Safety is defined as being protected from unintended code execution
+ * from content scripts (or cross-compartment code).
+ *
+ * See bugs 945920 and 946752 for discussion.
+ *
+ * @type Object obj
+ *       The object to check.
+ * @return Boolean
+ *         True if it is safe to read properties from obj, or false otherwise.
+ */
+exports.isSafeJSObject = function (obj) {
+  // If we are running on a worker thread, Cu is not available. In this case,
+  // we always return false, just to be on the safe side.
+  if (isWorker) {
+    return false;
+  }
+
+  if (
+    Cu.getGlobalForObject(obj) == Cu.getGlobalForObject(exports.isSafeJSObject)
+  ) {
+    // obj is not a cross-compartment wrapper.
+    return true;
+  }
+
+  // Xray wrappers protect against unintended code execution.
+  if (Cu.isXrayWrapper(obj)) {
+    return true;
+  }
+
+  // If there aren't Xrays, only allow chrome objects.
+  const principal = Cu.getObjectPrincipal(obj);
+  if (!principal.isSystemPrincipal) {
+    return false;
+  }
+
+  // Scripted proxy objects without Xrays can run their proxy traps.
+  if (Cu.isProxy(obj)) {
+    return false;
+  }
+
+  // Even if `obj` looks safe, an unsafe object in its prototype chain may still
+  // run unintended code, e.g. when using the `instanceof` operator.
+  const proto = Object.getPrototypeOf(obj);
+  if (proto && !exports.isSafeJSObject(proto)) {
+    return false;
+  }
+
+  // Allow non-problematic chrome objects.
+  return true;
+};
+
+/**
+ * Dump with newline - This is a logging function that will only output when
+ * the preference "devtools.debugger.log" is set to true. Typically it is used
+ * for logging the remote debugging protocol calls.
+ */
+exports.dumpn = function (str) {
+  if (flags.wantLogging) {
+    dump("DBG-SERVER: " + str + "\n");
+  }
+};
+
+/**
+ * Dump verbose - This is a verbose logger for low-level tracing, that is typically
+ * used to provide information about the remote debugging protocol's transport
+ * mechanisms. The logging can be enabled by changing the preferences
+ * "devtools.debugger.log" and "devtools.debugger.log.verbose" to true.
+ */
+exports.dumpv = function (msg) {
+  if (flags.wantVerbose) {
+    exports.dumpn(msg);
+  }
+};
+
+/**
+ * Defines a getter on a specified object that will be created upon first use.
+ *
+ * @param object
+ *        The object to define the lazy getter on.
+ * @param name
+ *        The name of the getter to define on object.
+ * @param lambda
+ *        A function that returns what the getter should return.  This will
+ *        only ever be called once.
+ */
+exports.defineLazyGetter = function (object, name, lambda) {
+  Object.defineProperty(object, name, {
+    get() {
+      delete object[name];
+      object[name] = lambda.apply(object);
+      return object[name];
+    },
+    configurable: true,
+    enumerable: true,
+  });
+};
+
+DevToolsUtils.defineLazyGetter(this, "AppConstants", () => {
+  if (isWorker) {
+    return {};
+  }
+  return ChromeUtils.importESModule(
+    "resource://gre/modules/AppConstants.sys.mjs"
+  ).AppConstants;
+});
+
+/**
+ * No operation. The empty function.
+ */
+exports.noop = function () {};
+
+let assertionFailureCount = 0;
+
+Object.defineProperty(exports, "assertionFailureCount", {
+  get() {
+    return assertionFailureCount;
+  },
+});
+
+function reallyAssert(condition, message) {
+  if (!condition) {
+    assertionFailureCount++;
+    const err = new Error("Assertion failure: " + message);
+    exports.reportException("DevToolsUtils.assert", err);
+    throw err;
+  }
+}
+
+/**
+ * DevToolsUtils.assert(condition, message)
+ *
+ * @param Boolean condition
+ * @param String message
+ *
+ * Assertions are enabled when any of the following are true:
+ *   - This is a DEBUG_JS_MODULES build
+ *   - flags.testing is set to true
+ *
+ * If assertions are enabled, then `condition` is checked and if false-y, the
+ * assertion failure is logged and then an error is thrown.
+ *
+ * If assertions are not enabled, then this function is a no-op.
+ */
+Object.defineProperty(exports, "assert", {
+  get: () =>
+    AppConstants.DEBUG_JS_MODULES || flags.testing
+      ? reallyAssert
+      : exports.noop,
+});
+
+DevToolsUtils.defineLazyGetter(this, "NetUtil", () => {
+  return ChromeUtils.import("resource://gre/modules/NetUtil.jsm").NetUtil;
+});
+
+/**
+ * Performs a request to load the desired URL and returns a promise.
+ *
+ * @param urlIn String
+ *        The URL we will request.
+ * @param aOptions Object
+ *        An object with the following optional properties:
+ *        - loadFromCache: if false, will bypass the cache and
+ *          always load fresh from the network (default: true)
+ *        - policy: the nsIContentPolicy type to apply when fetching the URL
+ *                  (only works when loading from system principal)
+ *        - window: the window to get the loadGroup from
+ *        - charset: the charset to use if the channel doesn't provide one
+ *        - principal: the principal to use, if omitted, the request is loaded
+ *                     with a content principal corresponding to the url being
+ *                     loaded, using the origin attributes of the window, if any.
+ *        - cacheKey: when loading from cache, use this key to retrieve a cache
+ *                    specific to a given SHEntry. (Allows loading POST
+ *                    requests from cache)
+ * @returns Promise that resolves with an object with the following members on
+ *          success:
+ *           - content: the document at that URL, as a string,
+ *           - contentType: the content type of the document
+ *
+ *          If an error occurs, the promise is rejected with that error.
+ *
+ * XXX: It may be better to use nsITraceableChannel to get to the sources
+ * without relying on caching when we can (not for eval, etc.):
+ * http://www.softwareishard.com/blog/firebug/nsitraceablechannel-intercept-http-traffic/
+ */
+function mainThreadFetch(
+  urlIn,
+  aOptions = {
+    loadFromCache: true,
+    policy: Ci.nsIContentPolicy.TYPE_OTHER,
+    window: null,
+    charset: null,
+    principal: null,
+    cacheKey: 0,
+  }
+) {
+  return new Promise((resolve, reject) => {
+    // Create a channel.
+    const url = urlIn.split(" -> ").pop();
+    let channel;
+    try {
+      channel = newChannelForURL(url, aOptions);
+    } catch (ex) {
+      reject(ex);
+      return;
+    }
+
+    channel.loadInfo.isInDevToolsContext = true;
+
+    // Set the channel options.
+    channel.loadFlags = aOptions.loadFromCache
+      ? channel.LOAD_FROM_CACHE
+      : channel.LOAD_BYPASS_CACHE;
+
+    if (aOptions.loadFromCache && channel instanceof Ci.nsICacheInfoChannel) {
+      // If DevTools intents to load the content from the cache,
+      // we make the LOAD_FROM_CACHE flag preferred over LOAD_BYPASS_CACHE.
+      channel.preferCacheLoadOverBypass = true;
+
+      // When loading from cache, the cacheKey allows us to target a specific
+      // SHEntry and offer ways to restore POST requests from cache.
+      if (aOptions.cacheKey != 0) {
+        channel.cacheKey = aOptions.cacheKey;
+      }
+    }
+
+    if (aOptions.window) {
+      // Respect private browsing.
+      channel.loadGroup = aOptions.window.docShell.QueryInterface(
+        Ci.nsIDocumentLoader
+      ).loadGroup;
+    }
+
+    // eslint-disable-next-line complexity
+    const onResponse = (stream, status, request) => {
+      if (!Components.isSuccessCode(status)) {
+        reject(new Error(`Failed to fetch ${url}. Code ${status}.`));
+        return;
+      }
+
+      try {
+        // We cannot use NetUtil to do the charset conversion as if charset
+        // information is not available and our default guess is wrong the method
+        // might fail and we lose the stream data. This means we can't fall back
+        // to using the locale default encoding (bug 1181345).
+
+        // Read and decode the data according to the locale default encoding.
+
+        let available;
+        try {
+          available = stream.available();
+        } catch (ex) {
+          if (ex.name === "NS_BASE_STREAM_CLOSED") {
+            // Empty files cause NS_BASE_STREAM_CLOSED exception.
+            // If there was a real stream error, we would have already rejected above.
+            resolve({
+              content: "",
+              contentType: "text/plan",
+            });
+            return;
+          }
+
+          reject(ex);
+        }
+        let source = NetUtil.readInputStreamToString(stream, available);
+        stream.close();
+
+        // We do our own BOM sniffing here because there's no convenient
+        // implementation of the "decode" algorithm
+        // (https://encoding.spec.whatwg.org/#decode) exposed to JS.
+        let bomCharset = null;
+        if (
+          available >= 3 &&
+          source.codePointAt(0) == 0xef &&
+          source.codePointAt(1) == 0xbb &&
+          source.codePointAt(2) == 0xbf
+        ) {
+          bomCharset = "UTF-8";
+          source = source.slice(3);
+        } else if (
+          available >= 2 &&
+          source.codePointAt(0) == 0xfe &&
+          source.codePointAt(1) == 0xff
+        ) {
+          bomCharset = "UTF-16BE";
+          source = source.slice(2);
+        } else if (
+          available >= 2 &&
+          source.codePointAt(0) == 0xff &&
+          source.codePointAt(1) == 0xfe
+        ) {
+          bomCharset = "UTF-16LE";
+          source = source.slice(2);
+        }
+
+        // If the channel or the caller has correct charset information, the
+        // content will be decoded correctly. If we have to fall back to UTF-8 and
+        // the guess is wrong, the conversion fails and convertToUnicode returns
+        // the input unmodified. Essentially we try to decode the data as UTF-8
+        // and if that fails, we use the locale specific default encoding. This is
+        // the best we can do if the source does not provide charset info.
+        let charset = bomCharset;
+        if (!charset) {
+          try {
+            charset = channel.contentCharset;
+          } catch (e) {
+            // Accessing `contentCharset` on content served by a service worker in
+            // non-e10s may throw.
+          }
+        }
+        if (!charset) {
+          charset = aOptions.charset || "UTF-8";
+        }
+        const unicodeSource = lazy.NetworkHelper.convertToUnicode(
+          source,
+          charset
+        );
+
+        // Look for any source map URL in the response.
+        let sourceMapURL;
+        if (request instanceof Ci.nsIHttpChannel) {
+          try {
+            sourceMapURL = request.getResponseHeader("SourceMap");
+          } catch (e) {}
+          if (!sourceMapURL) {
+            try {
+              sourceMapURL = request.getResponseHeader("X-SourceMap");
+            } catch (e) {}
+          }
+        }
+
+        resolve({
+          content: unicodeSource,
+          contentType: request.contentType,
+          sourceMapURL,
+        });
+      } catch (ex) {
+        reject(ex);
+      }
+    };
+
+    // Open the channel
+    try {
+      NetUtil.asyncFetch(channel, onResponse);
+    } catch (ex) {
+      reject(ex);
+    }
+  });
+}
+
+/**
+ * Opens a channel for given URL. Tries a bit harder than NetUtil.newChannel.
+ *
+ * @param {String} url - The URL to open a channel for.
+ * @param {Object} options - The options object passed to @method fetch.
+ * @return {nsIChannel} - The newly created channel. Throws on failure.
+ */
+function newChannelForURL(
+  url,
+  { policy, window, principal },
+  recursing = false
+) {
+  const securityFlags =
+    Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL;
+
+  let uri;
+  try {
+    uri = Services.io.newURI(url);
+  } catch (e) {
+    // In the xpcshell tests, the script url is the absolute path of the test
+    // file, which will make a malformed URI error be thrown. Add the file
+    // scheme to see if it helps.
+    uri = Services.io.newURI("file://" + url);
+  }
+  const channelOptions = {
+    contentPolicyType: policy,
+    securityFlags,
+    uri,
+  };
+
+  // Ensure that we have some contentPolicyType type set if one was
+  // not provided.
+  if (!channelOptions.contentPolicyType) {
+    channelOptions.contentPolicyType = Ci.nsIContentPolicy.TYPE_OTHER;
+  }
+
+  // If a window is provided, always use it's document as the loadingNode.
+  // This will provide the correct principal, origin attributes, service
+  // worker controller, etc.
+  if (window) {
+    channelOptions.loadingNode = window.document;
+  } else {
+    // If a window is not provided, then we must set a loading principal.
+
+    // If the caller did not provide a principal, then we use the URI
+    // to create one.  Note, it's not clear what use cases require this
+    // and it may not be correct.
+    let prin = principal;
+    if (!prin) {
+      prin = Services.scriptSecurityManager.createContentPrincipal(uri, {});
+    }
+
+    channelOptions.loadingPrincipal = prin;
+  }
+
+  try {
+    return NetUtil.newChannel(channelOptions);
+  } catch (e) {
+    // Don't infinitely recurse if newChannel keeps throwing.
+    if (recursing) {
+      throw e;
+    }
+
+    // In xpcshell tests on Windows, nsExternalProtocolHandler::NewChannel()
+    // can throw NS_ERROR_UNKNOWN_PROTOCOL if the external protocol isn't
+    // supported by Windows, so we also need to handle the exception here if
+    // parsing the URL above doesn't throw.
+    return newChannelForURL(
+      "file://" + url,
+      { policy, window, principal },
+      /* recursing */ true
+    );
+  }
+}
+
+// Fetch is defined differently depending on whether we are on the main thread
+// or a worker thread.
+if (this.isWorker) {
+  // Services is not available in worker threads, nor is there any other way
+  // to fetch a URL. We need to enlist the help from the main thread here, by
+  // issuing an rpc request, to fetch the URL on our behalf.
+  exports.fetch = function (url, options) {
+    return rpc("fetch", url, options);
+  };
+} else {
+  exports.fetch = mainThreadFetch;
+}
+
+/**
+ * Open the file at the given path for reading.
+ *
+ * @param {String} filePath
+ *
+ * @returns Promise<nsIInputStream>
+ */
+exports.openFileStream = function (filePath) {
+  return new Promise((resolve, reject) => {
+    const uri = NetUtil.newURI(new lazy.FileUtils.File(filePath));
+    NetUtil.asyncFetch(
+      { uri, loadUsingSystemPrincipal: true },
+      (stream, result) => {
+        if (!Components.isSuccessCode(result)) {
+          reject(new Error(`Could not open "${filePath}": result = ${result}`));
+          return;
+        }
+
+        resolve(stream);
+      }
+    );
+  });
+};
+
+/**
+ * Save the given data to disk after asking the user where to do so.
+ *
+ * @param {Window} parentWindow
+ *        The parent window to use to display the filepicker.
+ * @param {UInt8Array} dataArray
+ *        The data to write to the file.
+ * @param {String} fileName
+ *        The suggested filename.
+ * @param {Array} filters
+ *        An array of object of the following shape:
+ *          - pattern: A pattern for accepted files (example: "*.js")
+ *          - label: The label that will be displayed in the save file dialog.
+ * @return {String|null}
+ *        The path to the local saved file, if saved.
+ */
+exports.saveAs = async function (
+  parentWindow,
+  dataArray,
+  fileName = "",
+  filters = []
+) {
+  let returnFile;
+  try {
+    returnFile = await exports.showSaveFileDialog(
+      parentWindow,
+      fileName,
+      filters
+    );
+  } catch (ex) {
+    return null;
+  }
+
+  await IOUtils.write(returnFile.path, dataArray, {
+    tmpPath: returnFile.path + ".tmp",
+  });
+
+  return returnFile.path;
+};
+
+/**
+ * Show file picker and return the file user selected.
+ *
+ * @param {nsIWindow} parentWindow
+ *        Optional parent window. If null the parent window of the file picker
+ *        will be the window of the attached input element.
+ * @param {String} suggestedFilename
+ *        The suggested filename.
+ * @param {Array} filters
+ *        An array of object of the following shape:
+ *          - pattern: A pattern for accepted files (example: "*.js")
+ *          - label: The label that will be displayed in the save file dialog.
+ * @return {Promise}
+ *         A promise that is resolved after the file is selected by the file picker
+ */
+exports.showSaveFileDialog = function (
+  parentWindow,
+  suggestedFilename,
+  filters = []
+) {
+  const fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
+
+  if (suggestedFilename) {
+    fp.defaultString = suggestedFilename;
+  }
+
+  fp.init(parentWindow, null, fp.modeSave);
+  if (Array.isArray(filters) && filters.length) {
+    for (const { pattern, label } of filters) {
+      fp.appendFilter(label, pattern);
+    }
+  } else {
+    fp.appendFilters(fp.filterAll);
+  }
+
+  return new Promise((resolve, reject) => {
+    fp.open(result => {
+      if (result == Ci.nsIFilePicker.returnCancel) {
+        reject();
+      } else {
+        resolve(fp.file);
+      }
+    });
+  });
+};
+
+/*
+ * All of the flags have been moved to a different module. Make sure
+ * nobody is accessing them anymore, and don't write new code using
+ * them. We can remove this code after a while.
+ */
+function errorOnFlag(exports, name) {
+  Object.defineProperty(exports, name, {
+    get: () => {
+      const msg =
+        `Cannot get the flag ${name}. ` +
+        `Use the "devtools/shared/flags" module instead`;
+      console.error(msg);
+      throw new Error(msg);
+    },
+    set: () => {
+      const msg =
+        `Cannot set the flag ${name}. ` +
+        `Use the "devtools/shared/flags" module instead`;
+      console.error(msg);
+      throw new Error(msg);
+    },
+  });
+}
+
+errorOnFlag(exports, "testing");
+errorOnFlag(exports, "wantLogging");
+errorOnFlag(exports, "wantVerbose");
+
+// Calls the property with the given `name` on the given `object`, where
+// `name` is a string, and `object` a Debugger.Object instance.
+//
+// This function uses only the Debugger.Object API to call the property. It
+// avoids the use of unsafeDeference. This is useful for example in workers,
+// where unsafeDereference will return an opaque security wrapper to the
+// referent.
+function callPropertyOnObject(object, name, ...args) {
+  // Find the property.
+  let descriptor;
+  let proto = object;
+  do {
+    descriptor = proto.getOwnPropertyDescriptor(name);
+    if (descriptor !== undefined) {
+      break;
+    }
+    proto = proto.proto;
+  } while (proto !== null);
+  if (descriptor === undefined) {
+    throw new Error("No such property");
+  }
+  const value = descriptor.value;
+  if (typeof value !== "object" || value === null || !("callable" in value)) {
+    throw new Error("Not a callable object.");
+  }
+
+  // Call the property.
+  const result = value.call(object, ...args);
+  if (result === null) {
+    throw new Error("Code was terminated.");
+  }
+  if ("throw" in result) {
+    throw result.throw;
+  }
+  return result.return;
+}
+
+exports.callPropertyOnObject = callPropertyOnObject;
+
+// Convert a Debugger.Object wrapping an iterator into an iterator in the
+// debugger's realm.
+function* makeDebuggeeIterator(object) {
+  while (true) {
+    const nextValue = callPropertyOnObject(object, "next");
+    if (exports.getProperty(nextValue, "done")) {
+      break;
+    }
+    yield exports.getProperty(nextValue, "value");
+  }
+}
+
+exports.makeDebuggeeIterator = makeDebuggeeIterator;
+
+/**
+ * Shared helper to retrieve the topmost window. This can be used to retrieve the chrome
+ * window embedding the DevTools frame.
+ */
+function getTopWindow(win) {
+  return win.windowRoot ? win.windowRoot.ownerGlobal : win.top;
+}
+
+exports.getTopWindow = getTopWindow;
+
+/**
+ * Check whether two objects are identical by performing
+ * a deep equality check on their properties and values.
+ * See toolkit/modules/ObjectUtils.jsm for implementation.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Boolean}
+ */
+exports.deepEqual = (a, b) => {
+  return lazy.ObjectUtils.deepEqual(a, b);
+};
+
+function isWorkerDebuggerAlive(dbg) {
+  // Some workers are zombies. `isClosed` is false, but nothing works.
+  // `postMessage` is a noop, `addListener`'s `onClosed` doesn't work.
+  // (Ignore dbg without `window` as they aren't related to docShell
+  //  and probably do not suffer form this issue)
+  return !dbg.isClosed && (!dbg.window || dbg.window.docShell);
+}
+exports.isWorkerDebuggerAlive = isWorkerDebuggerAlive;