Enable firefox

1 files changed, 415 insertions, 0 deletions

diff --git a/modules/firefox.home/chrome/utils/ChromeManifest.sys.mjs b/modules/firefox.home/chrome/utils/ChromeManifest.sys.mjs
new file mode 100644
index 0000000..f2ebc18
--- /dev/null
+++ b/modules/firefox.home/chrome/utils/ChromeManifest.sys.mjs
@@ -0,0 +1,415 @@
+/* exported ChromeManifest */
+"use strict";
+
+/**
+ * A default map, which assumes a default value on get() if the key doesn't exist
+ */
+class DefaultMap extends Map {
+  /**
+   * Constructs the default map
+   *
+   * @param {Function} _default     A function that returns the default value for this map
+   * @param {*} iterable            An iterable to initialize the map with
+   */
+  constructor(_default, iterable) {
+    super(iterable);
+    this._default = _default;
+  }
+
+  /**
+   * Get the given key, creating if necessary
+   *
+   * @param {String} key            The key of the map to get
+   * @param {Boolean} create        True, if the key should be created in case it doesn't exist.
+   */
+  get(key, create = true) {
+    if (this.has(key)) {
+      return super.get(key);
+    } else if (create) {
+      this.set(key, this._default());
+      return super.get(key);
+    }
+
+    return this._default();
+  }
+}
+
+/**
+ * A parser for chrome.manifest files. Implements a subset of
+ * https://developer.mozilla.org/en-US/docs/Mozilla/Chrome_Registration
+ */
+export class ChromeManifest {
+  /**
+   * Constucts the chrome.manifest parser
+   *
+   * @param {Function} loader           An asynchronous function that will load further files, e.g.
+   *                                      those included via the |manifest| instruction. The
+   *                                      function will take the file as an argument and should
+   *                                      resolve with the string contents of that file
+   * @param {Object} options            Object describing the current system. The keys are manifest
+   *                                      instructions
+   */
+  constructor(loader, options) {
+    this.loader = loader;
+    this.options = options;
+
+    this.overlay = new DefaultMap(() => []);
+    this.locales = new DefaultMap(() => new Map());
+    this.style = new DefaultMap(() => new Set());
+    this.category = new DefaultMap(() => new Map());
+
+    this.component = new Map();
+    this.contract = new Map();
+
+    this.content = new Map();
+    this.skin = new DefaultMap(() => new Map());
+    this.resource = new Map();
+    this.override = new Map();
+  }
+
+  /**
+   * Parse the given file.
+   *
+   * @param {String} filename           The filename to load
+   * @param {String} base               The relative directory this file is expected to be in.
+   * @return {Promise}                  Resolved when loading completes
+   */
+  async parse(filename = "chrome.manifest", base = "") {
+    await this.parseString(await this.loader(filename), base);
+  }
+
+  /**
+   * Parse the given string.
+   *
+   * @param {String} data               The file data to load
+   * @param {String} base               The relative directory this file is expected to be in.
+   * @return {Promise}                  Resolved when loading completes
+   */
+  async parseString(data, base = "") {
+    const lines = data.split("\n");
+    const extraManifests = [];
+    for (const line of lines) {
+      const parts = line.split(/\s+/);
+      const directive = parts.shift();
+      switch (directive) {
+        case "manifest":
+          extraManifests.push(this._parseManifest(base, ...parts));
+          break;
+        case "component": this._parseComponent(...parts);
+          break;
+        case "contract": this._parseContract(...parts);
+          break;
+        case "category": this._parseCategory(...parts);
+          break;
+        case "content": this._parseContent(...parts);
+          break;
+        case "locale": this._parseLocale(...parts);
+          break;
+        case "skin": this._parseSkin(...parts);
+          break;
+        case "resource": this._parseResource(...parts);
+          break;
+        case "overlay": this._parseOverlay(...parts);
+          break;
+        case "style": this._parseStyle(...parts);
+          break;
+        case "override": this._parseOverride(...parts);
+          break;
+      }
+    }
+
+    await Promise.all(extraManifests);
+  }
+
+  /**
+   * Ensure the flags provided for the instruction match our options
+   *
+   * @param {String[]} flags        An array of raw flag values in the form key=value.
+   * @return {Boolean}              True, if the flags match the options provided in the constructor
+   */
+  _parseFlags(flags) {
+    const matchString = (a, sign, b) => {
+      if (sign != "=") {
+        console.warn(`Invalid sign ${sign} in ${a}${sign}${b}, dropping manifest instruction`);
+        return false;
+      }
+      return a == b;
+    };
+
+    const matchVersion = (a, sign, b) => {
+      switch (sign) {
+        case "=": return Services.vc.compare(a, b) == 0;
+        case ">": return Services.vc.compare(a, b) > 0;
+        case "<": return Services.vc.compare(a, b) < 0;
+        case ">=": return Services.vc.compare(a, b) >= 0;
+        case "<=": return Services.vc.compare(a, b) <= 0;
+        default:
+          console.warn(`Invalid sign ${sign} in ${a}${sign}${b}, dropping manifest instruction`);
+          return false;
+      }
+    };
+
+    const flagdata = new DefaultMap(() => []);
+
+    const flagMatches = (key, typeMatch) => {
+      return !flagdata.has(key) || flagdata.get(key).some(val => typeMatch(this.options[key], ...val));
+    };
+
+    for (const flag of flags) {
+      const match = flag.match(/(\w+)(>=|<=|<|>|=)(.*)/);
+      if (match) {
+        flagdata.get(match[1]).push([match[2], match[3]]);
+      } else {
+        console.warn(`Invalid flag ${flag}, dropping manifest instruction`);
+      }
+    }
+
+    return flagMatches("application", matchString) &&
+           flagMatches("appversion", matchVersion) &&
+           flagMatches("platformversion", matchVersion) &&
+           flagMatches("os", matchString) &&
+           flagMatches("osversion", matchVersion) &&
+           flagMatches("abi", matchString);
+  }
+
+  /**
+   * Parse the manifest instruction, to load other files
+   *
+   * @param {String} base       The base directory the manifest file is in
+   * @param {String} filename   The file and path to load
+   * @param {...String} flags   The flags for this instruction
+   * @return {Promise}          Promise resolved when the manifest is loaded
+   */
+  async _parseManifest(base, filename, ...flags) {
+    if (this._parseFlags(flags)) {
+      const dirparts = filename.split("/");
+      dirparts.pop();
+
+      try {
+        await this.parse(filename, base + "/" + dirparts.join("/"));
+      } catch (e) {
+        console.log(`Could not read manifest '${base}/${filename}'.`);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parse the component instruction, to load xpcom components
+   *
+   * @param {String} classid        The xpcom class id to load
+   * @param {String} loction        The file location of this component
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseComponent(classid, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.component.set(classid, location);
+    }
+  }
+
+  /**
+   * Parse the contract instruction, to load xpcom contract ids
+   *
+   * @param {String} contractid     The xpcom contract id to load
+   * @param {String} location       The file location of this component
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseContract(contractid, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.contract.set(contractid, location);
+    }
+  }
+
+  /**
+   * Parse the category instruction, to set up xpcom categories
+   *
+   * @param {String} category       The name of the category
+   * @param {String} entryName      The category entry name
+   * @param {String} value          The category entry value
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseCategory(category, entryName, value, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.category.get(category).set(entryName, value);
+    }
+  }
+
+  /**
+   * Parse the content instruction, to set chrome content locations
+   *
+   * @param {String} shortname      The content short name, e.g. chrome://shortname/content/
+   * @param {String} location       The location for this content registration
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseContent(shortname, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.content.set(shortname, location);
+    }
+  }
+
+  /**
+   * Parse the locale instruction, to set chrome locale locations
+   *
+   * @param {String} shortname      The locale short name, e.g. chrome://shortname/locale/
+   * @param {String} location       The location for this locale registration
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseLocale(shortname, locale, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.locales.get(shortname).set(locale, location);
+    }
+  }
+
+  /**
+   * Parse the skin instruction, to set chrome skin locations
+   *
+   * @param {String} shortname      The skin short name, e.g. chrome://shortname/skin/
+   * @param {String} location       The location for this skin registration
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseSkin(packagename, skinname, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.skin.get(packagename).set(skinname, location);
+    }
+  }
+
+  /**
+   * Parse the resource instruction, to set up resource uri subtitutions
+   *
+   * @param {String} packagename    The resource package name, e.g. resource://packagename/
+   * @param {String} url            The location for this content registration
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseResource(packagename, location, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.resource.set(packagename, location);
+    }
+  }
+
+  /**
+   * Parse the overlay instruction, to set up xul overlays
+   *
+   * @param {String} targetUrl      The chrome target url
+   * @param {String} overlayUrl     The url of the xul overlay
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseOverlay(targetUrl, overlayUrl, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.overlay.get(targetUrl).push(overlayUrl);
+    }
+  }
+
+  /**
+   * Parse the style instruction, to add stylesheets into chrome windows
+   *
+   * @param {String} uri            The uri of the chrome window
+   * @param {String} sheet          The uri of the css sheet
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseStyle(uri, sheet, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.style.get(uri).add(sheet);
+    }
+  }
+
+  /**
+   * Parse the override instruction, to set chrome uri overrides
+   *
+   * @param {String} uri            The uri being overridden
+   * @param {String} newuri         The replacement uri for the original location
+   * @param {...String} flags       The flags for this instruction
+   */
+  _parseOverride(uri, newuri, ...flags) {
+    if (this._parseFlags(flags)) {
+      this.override.set(uri, newuri);
+    }
+  }
+
+  /**
+   * Output the manifest data as a string in chrome.manifest format
+   * If root is provided, convert all relative locations to absolute paths.
+   *
+   * @param {String} [root]   The absolute path root to resolve relative locations
+   * @return {String}         The manifest contents as a string
+   */
+  toString(root = "") {
+    const lines = [];
+    const isRelative = loc => {
+      // Not absolute if doesn't start with /, \, or protocol (chrome://, resource://, etc)
+      return (
+        typeof loc === "string" &&
+        !loc.match(/^(?:[a-zA-Z]+:|\\|\/)/)
+      );
+    };
+    const absolutize = loc => {
+      if (!root) return loc;
+      if (loc === "/") return root;
+      if (isRelative(loc)) {
+        return root.replace(/[\\/]$/, "") + "/" + loc.replace(/^([\\\/])/, "");
+      }
+      return loc;
+    };
+
+    // Output components
+    for (const [classid, location] of this.component) {
+      lines.push(`component ${classid} ${absolutize(location)}`);
+    }
+
+    // Output contracts
+    for (const [contractid, location] of this.contract) {
+      lines.push(`contract ${contractid} ${absolutize(location)}`);
+    }
+
+    // Output categories
+    for (const [category, entries] of this.category) {
+      for (const [entryName, value] of entries) {
+        lines.push(`category ${category} ${entryName} ${value}`);
+      }
+    }
+
+    // Output content
+    for (const [shortname, location] of this.content) {
+      lines.push(`content ${shortname} ${absolutize(location)}`);
+    }
+
+    // Output locales
+    for (const [shortname, locales] of this.locales) {
+      for (const [locale, location] of locales) {
+        lines.push(`locale ${shortname} ${locale} ${absolutize(location)}`);
+      }
+    }
+
+    // Output skins
+    for (const [packagename, skins] of this.skin) {
+      for (const [skinname, location] of skins) {
+        lines.push(`skin ${packagename} ${skinname} ${absolutize(location)}`);
+      }
+    }
+
+    // Output resources
+    for (const [packagename, location] of this.resource) {
+      lines.push(`resource ${packagename} ${absolutize(location)}`);
+    }
+
+    // Output overlays
+    for (const [targetUrl, overlays] of this.overlay) {
+      for (const overlayUrl of overlays) {
+        lines.push(`overlay ${targetUrl} ${absolutize(overlayUrl)}`);
+      }
+    }
+
+    // Output styles
+    for (const [uri, sheets] of this.style) {
+      for (const sheet of sheets) {
+        lines.push(`style ${uri} ${absolutize(sheet)}`);
+      }
+    }
+
+    // Output overrides
+    for (const [uri, newuri] of this.override) {
+      lines.push(`override ${uri} ${newuri}`);
+    }
+
+    return lines.join("\n");
+  }
+}