Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

44 files changed, 3620 insertions, 0 deletions

diff --git a/dom/manifest/ImageObjectProcessor.sys.mjs b/dom/manifest/ImageObjectProcessor.sys.mjs
new file mode 100644
index 0000000000..f72c5ff9fe
--- /dev/null
+++ b/dom/manifest/ImageObjectProcessor.sys.mjs
@@ -0,0 +1,250 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+/*
+ * ImageObjectProcessor
+ * Implementation of Image Object processing algorithms from:
+ * http://www.w3.org/TR/appmanifest/#image-object-and-its-members
+ *
+ * This is intended to be used in conjunction with ManifestProcessor.jsm
+ *
+ * Creates an object to process Image Objects as defined by the
+ * W3C specification. This is used to process things like the
+ * icon member and the splash_screen member.
+ *
+ * Usage:
+ *
+ *   .process(aManifest, aBaseURL, aMemberName);
+ *
+ */
+
+export function ImageObjectProcessor(aErrors, aExtractor, aBundle) {
+  this.errors = aErrors;
+  this.extractor = aExtractor;
+  this.domBundle = aBundle;
+}
+
+const iconPurposes = Object.freeze(["any", "maskable", "monochrome"]);
+
+// Static getters
+Object.defineProperties(ImageObjectProcessor, {
+  decimals: {
+    get() {
+      return /^\d+$/;
+    },
+  },
+  anyRegEx: {
+    get() {
+      return new RegExp("any", "i");
+    },
+  },
+});
+
+ImageObjectProcessor.prototype.process = function (
+  aManifest,
+  aBaseURL,
+  aMemberName
+) {
+  const spec = {
+    objectName: "manifest",
+    object: aManifest,
+    property: aMemberName,
+    expectedType: "array",
+    trim: false,
+  };
+  const { domBundle, extractor, errors } = this;
+  const images = [];
+  const value = extractor.extractValue(spec);
+  if (Array.isArray(value)) {
+    value
+      .map(toImageObject)
+      // Filter out images that resulted in "failure", per spec.
+      .filter(image => image)
+      .forEach(image => images.push(image));
+  }
+  return images;
+
+  function toImageObject(aImageSpec, index) {
+    let img; // if "failure" happens below, we return undefined.
+    try {
+      // can throw
+      const src = processSrcMember(aImageSpec, aBaseURL, index);
+      // can throw
+      const purpose = processPurposeMember(aImageSpec, index);
+      const type = processTypeMember(aImageSpec);
+      const sizes = processSizesMember(aImageSpec);
+      img = {
+        src,
+        purpose,
+        type,
+        sizes,
+      };
+    } catch (err) {
+      /* Errors are collected by each process* function */
+    }
+    return img;
+  }
+
+  function processPurposeMember(aImage, index) {
+    const spec = {
+      objectName: "image",
+      object: aImage,
+      property: "purpose",
+      expectedType: "string",
+      trim: true,
+      throwTypeError: true,
+    };
+
+    // Type errors are treated at "any"...
+    let value;
+    try {
+      value = extractor.extractValue(spec);
+    } catch (err) {
+      return ["any"];
+    }
+
+    // Was only whitespace...
+    if (!value) {
+      return ["any"];
+    }
+
+    const keywords = value.split(/\s+/);
+
+    // Emtpy is treated as "any"...
+    if (keywords.length === 0) {
+      return ["any"];
+    }
+
+    // We iterate over keywords and classify them into:
+    const purposes = new Set();
+    const unknownPurposes = new Set();
+    const repeatedPurposes = new Set();
+
+    for (const keyword of keywords) {
+      const canonicalKeyword = keyword.toLowerCase();
+
+      if (purposes.has(canonicalKeyword)) {
+        repeatedPurposes.add(keyword);
+        continue;
+      }
+
+      iconPurposes.includes(canonicalKeyword)
+        ? purposes.add(canonicalKeyword)
+        : unknownPurposes.add(keyword);
+    }
+
+    // Tell developer about unknown purposes...
+    if (unknownPurposes.size) {
+      const warn = domBundle.formatStringFromName(
+        "ManifestImageUnsupportedPurposes",
+        [aMemberName, index, [...unknownPurposes].join(" ")]
+      );
+      errors.push({ warn });
+    }
+
+    // Tell developer about repeated purposes...
+    if (repeatedPurposes.size) {
+      const warn = domBundle.formatStringFromName(
+        "ManifestImageRepeatedPurposes",
+        [aMemberName, index, [...repeatedPurposes].join(" ")]
+      );
+      errors.push({ warn });
+    }
+
+    if (purposes.size === 0) {
+      const warn = domBundle.formatStringFromName("ManifestImageUnusable", [
+        aMemberName,
+        index,
+      ]);
+      errors.push({ warn });
+      throw new TypeError(warn);
+    }
+
+    return [...purposes];
+  }
+
+  function processTypeMember(aImage) {
+    const charset = {};
+    const hadCharset = {};
+    const spec = {
+      objectName: "image",
+      object: aImage,
+      property: "type",
+      expectedType: "string",
+      trim: true,
+    };
+    let value = extractor.extractValue(spec);
+    if (value) {
+      value = Services.io.parseRequestContentType(value, charset, hadCharset);
+    }
+    return value || undefined;
+  }
+
+  function processSrcMember(aImage, aBaseURL, index) {
+    const spec = {
+      objectName: aMemberName,
+      object: aImage,
+      property: "src",
+      expectedType: "string",
+      trim: false,
+      throwTypeError: true,
+    };
+    const value = extractor.extractValue(spec);
+    let url;
+    if (typeof value === "undefined" || value === "") {
+      // We throw here as the value is unusable,
+      // but it's not an developer error.
+      throw new TypeError();
+    }
+    if (value && value.length) {
+      try {
+        url = new URL(value, aBaseURL).href;
+      } catch (e) {
+        const warn = domBundle.formatStringFromName(
+          "ManifestImageURLIsInvalid",
+          [aMemberName, index, "src", value]
+        );
+        errors.push({ warn });
+        throw e;
+      }
+    }
+    return url;
+  }
+
+  function processSizesMember(aImage) {
+    const sizes = new Set();
+    const spec = {
+      objectName: "image",
+      object: aImage,
+      property: "sizes",
+      expectedType: "string",
+      trim: true,
+    };
+    const value = extractor.extractValue(spec);
+    if (value) {
+      // Split on whitespace and filter out invalid values.
+      value
+        .split(/\s+/)
+        .filter(isValidSizeValue)
+        .reduce((collector, size) => collector.add(size), sizes);
+    }
+    return sizes.size ? Array.from(sizes) : undefined;
+    // Implementation of HTML's link@size attribute checker.
+    function isValidSizeValue(aSize) {
+      const size = aSize.toLowerCase();
+      if (ImageObjectProcessor.anyRegEx.test(aSize)) {
+        return true;
+      }
+      if (!size.includes("x") || size.indexOf("x") !== size.lastIndexOf("x")) {
+        return false;
+      }
+      // Split left of x for width, after x for height.
+      const widthAndHeight = size.split("x");
+      const w = widthAndHeight.shift();
+      const h = widthAndHeight.join("x");
+      const validStarts = !w.startsWith("0") && !h.startsWith("0");
+      const validDecimals = ImageObjectProcessor.decimals.test(w + h);
+      return validStarts && validDecimals;
+    }
+  }
+};
diff --git a/dom/manifest/Manifest.sys.mjs b/dom/manifest/Manifest.sys.mjs
new file mode 100644
index 0000000000..f6fab11277
--- /dev/null
+++ b/dom/manifest/Manifest.sys.mjs
@@ -0,0 +1,245 @@
+/* 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/. */
+
+/*
+ * Manifest.jsm is the top level api for managing installed web applications
+ * https://www.w3.org/TR/appmanifest/
+ *
+ * It is used to trigger the installation of a web application via .install()
+ * and to access the manifest data (including icons).
+ *
+ * TODO:
+ *  - Trigger appropriate app installed events
+ */
+
+import { ManifestObtainer } from "resource://gre/modules/ManifestObtainer.sys.mjs";
+
+import { ManifestIcons } from "resource://gre/modules/ManifestIcons.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  JSONFile: "resource://gre/modules/JSONFile.sys.mjs",
+});
+
+/**
+ * Generates an hash for the given string.
+ *
+ * @note The generated hash is returned in base64 form.  Mind the fact base64
+ * is case-sensitive if you are going to reuse this code.
+ */
+function generateHash(aString) {
+  const cryptoHash = Cc["@mozilla.org/security/hash;1"].createInstance(
+    Ci.nsICryptoHash
+  );
+  cryptoHash.init(Ci.nsICryptoHash.MD5);
+  const stringStream = Cc[
+    "@mozilla.org/io/string-input-stream;1"
+  ].createInstance(Ci.nsIStringInputStream);
+  stringStream.data = aString;
+  cryptoHash.updateFromStream(stringStream, -1);
+  // base64 allows the '/' char, but we can't use it for filenames.
+  return cryptoHash.finish(true).replace(/\//g, "-");
+}
+
+/**
+ * Trims the query parameters from a url
+ */
+function stripQuery(url) {
+  return url.split("?")[0];
+}
+
+// Folder in which we store the manifest files
+const MANIFESTS_DIR = PathUtils.join(PathUtils.profileDir, "manifests");
+
+// We maintain a list of scopes for installed webmanifests so we can determine
+// whether a given url is within the scope of a previously installed manifest
+const MANIFESTS_FILE = "manifest-scopes.json";
+
+/**
+ * Manifest object
+ */
+
+class Manifest {
+  constructor(browser, manifestUrl) {
+    this._manifestUrl = manifestUrl;
+    // The key for this is the manifests URL that is required to be unique.
+    // However arbitrary urls are not safe file paths so lets hash it.
+    const fileName = generateHash(manifestUrl) + ".json";
+    this._path = PathUtils.join(MANIFESTS_DIR, fileName);
+    this.browser = browser;
+  }
+
+  get browser() {
+    return this._browser;
+  }
+
+  set browser(aBrowser) {
+    this._browser = aBrowser;
+  }
+
+  async initialize() {
+    this._store = new lazy.JSONFile({ path: this._path, saveDelayMs: 100 });
+    await this._store.load();
+  }
+
+  async prefetch(browser) {
+    const manifestData = await ManifestObtainer.browserObtainManifest(browser);
+    const icon = await ManifestIcons.browserFetchIcon(
+      browser,
+      manifestData,
+      192
+    );
+    const data = {
+      installed: false,
+      manifest: manifestData,
+      cached_icon: icon,
+    };
+    return data;
+  }
+
+  async install() {
+    const manifestData = await ManifestObtainer.browserObtainManifest(
+      this._browser
+    );
+    this._store.data = {
+      installed: true,
+      manifest: manifestData,
+    };
+    Manifests.manifestInstalled(this);
+    this._store.saveSoon();
+  }
+
+  async icon(expectedSize) {
+    if ("cached_icon" in this._store.data) {
+      return this._store.data.cached_icon;
+    }
+    const icon = await ManifestIcons.browserFetchIcon(
+      this._browser,
+      this._store.data.manifest,
+      expectedSize
+    );
+    // Cache the icon so future requests do not go over the network
+    this._store.data.cached_icon = icon;
+    this._store.saveSoon();
+    return icon;
+  }
+
+  get scope() {
+    const scope =
+      this._store.data.manifest.scope || this._store.data.manifest.start_url;
+    return stripQuery(scope);
+  }
+
+  get name() {
+    return (
+      this._store.data.manifest.short_name ||
+      this._store.data.manifest.name ||
+      this._store.data.manifest.short_url
+    );
+  }
+
+  get url() {
+    return this._manifestUrl;
+  }
+
+  get installed() {
+    return (this._store.data && this._store.data.installed) || false;
+  }
+
+  get start_url() {
+    return this._store.data.manifest.start_url;
+  }
+
+  get path() {
+    return this._path;
+  }
+}
+
+/*
+ * Manifests maintains the list of installed manifests
+ */
+export var Manifests = {
+  async _initialize() {
+    if (this._readyPromise) {
+      return this._readyPromise;
+    }
+
+    // Prevent multiple initializations
+    this._readyPromise = (async () => {
+      // Make sure the manifests have the folder needed to save into
+      await IOUtils.makeDirectory(MANIFESTS_DIR, { ignoreExisting: true });
+
+      // Ensure any existing scope data we have about manifests is loaded
+      this._path = PathUtils.join(PathUtils.profileDir, MANIFESTS_FILE);
+      this._store = new lazy.JSONFile({ path: this._path });
+      await this._store.load();
+
+      // If we don't have any existing data, initialize empty
+      if (!this._store.data.hasOwnProperty("scopes")) {
+        this._store.data.scopes = new Map();
+      }
+    })();
+
+    // Cache the Manifest objects creates as they are references to files
+    // and we do not want multiple file handles
+    this.manifestObjs = new Map();
+    return this._readyPromise;
+  },
+
+  // When a manifest is installed, we save its scope so we can determine if
+  // future visits fall within this manifests scope
+  manifestInstalled(manifest) {
+    this._store.data.scopes[manifest.scope] = manifest.url;
+    this._store.saveSoon();
+  },
+
+  // Given a url, find if it is within an installed manifests scope and if so
+  // return that manifests url
+  findManifestUrl(url) {
+    for (let scope in this._store.data.scopes) {
+      if (url.startsWith(scope)) {
+        return this._store.data.scopes[scope];
+      }
+    }
+    return null;
+  },
+
+  // Get the manifest given a url, or if not look for a manifest that is
+  // tied to the current page
+  async getManifest(browser, manifestUrl) {
+    // Ensure we have all started up
+    if (!this._readyPromise) {
+      await this._initialize();
+    }
+
+    // If the client does not already know its manifestUrl, we take the
+    // url of the client and see if it matches the scope of any installed
+    // manifests
+    if (!manifestUrl) {
+      const url = stripQuery(browser.currentURI.spec);
+      manifestUrl = this.findManifestUrl(url);
+    }
+
+    // No matches so no manifest
+    if (manifestUrl === null) {
+      return null;
+    }
+
+    // If we have already created this manifest return cached
+    if (this.manifestObjs.has(manifestUrl)) {
+      const manifest = this.manifestObjs.get(manifestUrl);
+      if (manifest.browser !== browser) {
+        manifest.browser = browser;
+      }
+      return manifest;
+    }
+
+    // Otherwise create a new manifest object
+    const manifest = new Manifest(browser, manifestUrl);
+    this.manifestObjs.set(manifestUrl, manifest);
+    await manifest.initialize();
+    return manifest;
+  },
+};
diff --git a/dom/manifest/ManifestFinder.sys.mjs b/dom/manifest/ManifestFinder.sys.mjs
new file mode 100644
index 0000000000..1f8a23462b
--- /dev/null
+++ b/dom/manifest/ManifestFinder.sys.mjs
@@ -0,0 +1,57 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+export var ManifestFinder = {
+  /**
+   * Check from content process if DOM Window has a conforming
+   * manifest link relationship.
+   * @param aContent DOM Window to check.
+   * @return {Promise<Boolean>}
+   */
+  contentHasManifestLink(aContent) {
+    if (!aContent || isXULBrowser(aContent)) {
+      throw new TypeError("Invalid input.");
+    }
+    return checkForManifest(aContent);
+  },
+
+  /**
+   * Check from a XUL browser (parent process) if it's content document has a
+   * manifest link relationship.
+   * @param aBrowser The XUL browser to check.
+   * @return {Promise}
+   */
+  async browserHasManifestLink(aBrowser) {
+    if (!isXULBrowser(aBrowser)) {
+      throw new TypeError("Invalid input.");
+    }
+
+    const actor =
+      aBrowser.browsingContext.currentWindowGlobal.getActor("ManifestMessages");
+    const reply = await actor.sendQuery("DOM:WebManifest:hasManifestLink");
+    return reply.result;
+  },
+};
+
+function isXULBrowser(aBrowser) {
+  if (!aBrowser || !aBrowser.namespaceURI || !aBrowser.localName) {
+    return false;
+  }
+  const XUL_NS =
+    "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+  return aBrowser.namespaceURI === XUL_NS && aBrowser.localName === "browser";
+}
+
+function checkForManifest(aWindow) {
+  // Only top-level browsing contexts are valid.
+  if (!aWindow || aWindow.top !== aWindow) {
+    return false;
+  }
+  const elem = aWindow.document.querySelector("link[rel~='manifest']");
+  // Only if we have an element and a non-empty href attribute.
+  if (!elem || !elem.getAttribute("href")) {
+    return false;
+  }
+  return true;
+}
diff --git a/dom/manifest/ManifestIcons.sys.mjs b/dom/manifest/ManifestIcons.sys.mjs
new file mode 100644
index 0000000000..9994c40d55
--- /dev/null
+++ b/dom/manifest/ManifestIcons.sys.mjs
@@ -0,0 +1,82 @@
+/* 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/. */
+
+export var ManifestIcons = {
+  async browserFetchIcon(aBrowser, manifest, iconSize) {
+    const msgKey = "DOM:WebManifest:fetchIcon";
+
+    const actor =
+      aBrowser.browsingContext.currentWindowGlobal.getActor("ManifestMessages");
+    const reply = await actor.sendQuery(msgKey, { manifest, iconSize });
+    if (!reply.success) {
+      throw reply.result;
+    }
+    return reply.result;
+  },
+
+  async contentFetchIcon(aWindow, manifest, iconSize) {
+    return getIcon(aWindow, toIconArray(manifest.icons), iconSize);
+  },
+};
+
+function parseIconSize(size) {
+  if (size === "any" || size === "") {
+    // We want icons without size specified to sorted
+    // as the largest available icons
+    return Number.MAX_SAFE_INTEGER;
+  }
+  // 100x100 will parse as 100
+  return parseInt(size, 10);
+}
+
+// Create an array of icons sorted by their size
+function toIconArray(icons) {
+  const iconBySize = [];
+  icons.forEach(icon => {
+    const sizes = "sizes" in icon ? icon.sizes : "";
+    sizes.forEach(size => {
+      iconBySize.push({ src: icon.src, size: parseIconSize(size) });
+    });
+  });
+  return iconBySize.sort((a, b) => a.size - b.size);
+}
+
+async function getIcon(aWindow, icons, expectedSize) {
+  if (!icons.length) {
+    throw new Error("Could not find valid icon");
+  }
+  // We start trying the smallest icon that is larger than the requested
+  // size and go up to the largest icon if they fail, if all those fail
+  // go back down to the smallest
+  let index = icons.findIndex(icon => icon.size >= expectedSize);
+  if (index === -1) {
+    index = icons.length - 1;
+  }
+
+  return fetchIcon(aWindow, icons[index].src).catch(err => {
+    // Remove all icons with the failed source, the same source
+    // may have been used for multiple sizes
+    icons = icons.filter(x => x.src !== icons[index].src);
+    return getIcon(aWindow, icons, expectedSize);
+  });
+}
+
+async function fetchIcon(aWindow, src) {
+  const iconURL = new aWindow.URL(src, aWindow.location);
+  // If this is already a data URL then no need to load it again.
+  if (iconURL.protocol === "data:") {
+    return iconURL.href;
+  }
+
+  const request = new aWindow.Request(iconURL, { mode: "cors" });
+  request.overrideContentPolicyType(Ci.nsIContentPolicy.TYPE_IMAGE);
+  const response = await aWindow.fetch(request);
+  const blob = await response.blob();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
diff --git a/dom/manifest/ManifestObtainer.sys.mjs b/dom/manifest/ManifestObtainer.sys.mjs
new file mode 100644
index 0000000000..de2863442a
--- /dev/null
+++ b/dom/manifest/ManifestObtainer.sys.mjs
@@ -0,0 +1,162 @@
+/* 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/.
+ */
+/*
+ * ManifestObtainer is an implementation of:
+ * http://w3c.github.io/manifest/#obtaining
+ *
+ * Exposes 2 public method:
+ *
+ *  .contentObtainManifest(aContent) - used in content process
+ *  .browserObtainManifest(aBrowser) - used in browser/parent process
+ *
+ * both return a promise. If successful, you get back a manifest object.
+ *
+ * Import it with URL:
+ *   'chrome://global/content/manifestMessages.js'
+ *
+ * e10s IPC message from this components are handled by:
+ *   dom/ipc/manifestMessages.js
+ *
+ * Which is injected into every browser instance via browser.js.
+ */
+
+import { ManifestProcessor } from "resource://gre/modules/ManifestProcessor.sys.mjs";
+
+export var ManifestObtainer = {
+  /**
+   * Public interface for obtaining a web manifest from a XUL browser, to use
+   * on the parent process.
+   * @param  {XULBrowser} The browser to check for the manifest.
+   * @param {Object} aOptions
+   * @param {Boolean} aOptions.checkConformance If spec conformance messages should be collected.
+   *                                            Adds proprietary moz_* members to manifest.
+   * @return {Promise<Object>} The processed manifest.
+   */
+  async browserObtainManifest(
+    aBrowser,
+    aOptions = { checkConformance: false }
+  ) {
+    if (!isXULBrowser(aBrowser)) {
+      throw new TypeError("Invalid input. Expected XUL browser.");
+    }
+
+    const actor =
+      aBrowser.browsingContext.currentWindowGlobal.getActor("ManifestMessages");
+
+    const reply = await actor.sendQuery(
+      "DOM:ManifestObtainer:Obtain",
+      aOptions
+    );
+    if (!reply.success) {
+      const error = toError(reply.result);
+      throw error;
+    }
+    return reply.result;
+  },
+  /**
+   * Public interface for obtaining a web manifest from a XUL browser.
+   * @param {Window} aContent A content Window from which to extract the manifest.
+   * @param {Object} aOptions
+   * @param {Boolean} aOptions.checkConformance If spec conformance messages should be collected.
+   *                                            Adds proprietary moz_* members to manifest.
+   * @return {Promise<Object>} The processed manifest.
+   */
+  async contentObtainManifest(
+    aContent,
+    aOptions = { checkConformance: false }
+  ) {
+    if (!Services.prefs.getBoolPref("dom.manifest.enabled")) {
+      throw new Error(
+        "Obtaining manifest is disabled by pref: dom.manifest.enabled"
+      );
+    }
+    if (!aContent || isXULBrowser(aContent)) {
+      const err = new TypeError("Invalid input. Expected a DOM Window.");
+      return Promise.reject(err);
+    }
+    const response = await fetchManifest(aContent);
+    const result = await processResponse(response, aContent, aOptions);
+    const clone = Cu.cloneInto(result, aContent);
+    return clone;
+  },
+};
+
+function toError(aErrorClone) {
+  let error;
+  switch (aErrorClone.name) {
+    case "TypeError":
+      error = new TypeError();
+      break;
+    default:
+      error = new Error();
+  }
+  Object.getOwnPropertyNames(aErrorClone).forEach(
+    name => (error[name] = aErrorClone[name])
+  );
+  return error;
+}
+
+function isXULBrowser(aBrowser) {
+  if (!aBrowser || !aBrowser.namespaceURI || !aBrowser.localName) {
+    return false;
+  }
+  const XUL_NS =
+    "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+  return aBrowser.namespaceURI === XUL_NS && aBrowser.localName === "browser";
+}
+
+/**
+ * Asynchronously processes the result of response after having fetched
+ * a manifest.
+ * @param {Response} aResp Response from fetch().
+ * @param {Window} aContentWindow The content window.
+ * @return {Promise<Object>} The processed manifest.
+ */
+async function processResponse(aResp, aContentWindow, aOptions) {
+  const badStatus = aResp.status < 200 || aResp.status >= 300;
+  if (aResp.type === "error" || badStatus) {
+    const msg = `Fetch error: ${aResp.status} - ${aResp.statusText} at ${aResp.url}`;
+    throw new Error(msg);
+  }
+  const text = await aResp.text();
+  const args = {
+    jsonText: text,
+    manifestURL: aResp.url,
+    docURL: aContentWindow.location.href,
+  };
+  const processingOptions = Object.assign({}, args, aOptions);
+  const manifest = ManifestProcessor.process(processingOptions);
+  return manifest;
+}
+
+/**
+ * Asynchronously fetches a web manifest.
+ * @param {Window} a The content Window from where to extract the manifest.
+ * @return {Promise<Object>}
+ */
+async function fetchManifest(aWindow) {
+  if (!aWindow || aWindow.top !== aWindow) {
+    const msg = "Window must be a top-level browsing context.";
+    throw new Error(msg);
+  }
+  const elem = aWindow.document.querySelector("link[rel~='manifest']");
+  if (!elem || !elem.getAttribute("href")) {
+    // There is no actual manifest to fetch, we just return null.
+    return new aWindow.Response("null");
+  }
+  // Throws on malformed URLs
+  const manifestURL = new aWindow.URL(elem.href, elem.baseURI);
+  const reqInit = {
+    credentials: "omit",
+    mode: "cors",
+  };
+  if (elem.crossOrigin === "use-credentials") {
+    reqInit.credentials = "include";
+  }
+  const request = new aWindow.Request(manifestURL, reqInit);
+  request.overrideContentPolicyType(Ci.nsIContentPolicy.TYPE_WEB_MANIFEST);
+  // Can reject...
+  return aWindow.fetch(request);
+}
diff --git a/dom/manifest/ManifestProcessor.sys.mjs b/dom/manifest/ManifestProcessor.sys.mjs
new file mode 100644
index 0000000000..6a7ea3b159
--- /dev/null
+++ b/dom/manifest/ManifestProcessor.sys.mjs
@@ -0,0 +1,345 @@
+/* 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/. */
+/*
+ * ManifestProcessor
+ * Implementation of processing algorithms from:
+ * http://www.w3.org/2008/webapps/manifest/
+ *
+ * Creates manifest processor that lets you process a JSON file
+ * or individual parts of a manifest object. A manifest is just a
+ * standard JS object that has been cleaned up.
+ *
+ *   .process({jsonText,manifestURL,docURL});
+ *
+ * Depends on ImageObjectProcessor to process things like
+ * icons and splash_screens.
+ *
+ * TODO: The constructor should accept the UA's supported orientations.
+ * TODO: The constructor should accept the UA's supported display modes.
+ */
+
+const displayModes = new Set([
+  "fullscreen",
+  "standalone",
+  "minimal-ui",
+  "browser",
+]);
+const orientationTypes = new Set([
+  "any",
+  "natural",
+  "landscape",
+  "portrait",
+  "portrait-primary",
+  "portrait-secondary",
+  "landscape-primary",
+  "landscape-secondary",
+]);
+const textDirections = new Set(["ltr", "rtl", "auto"]);
+
+// ValueExtractor is used by the various processors to get values
+// from the manifest and to report errors.
+import { ValueExtractor } from "resource://gre/modules/ValueExtractor.sys.mjs";
+
+// ImageObjectProcessor is used to process things like icons and images
+import { ImageObjectProcessor } from "resource://gre/modules/ImageObjectProcessor.sys.mjs";
+
+const domBundle = Services.strings.createBundle(
+  "chrome://global/locale/dom/dom.properties"
+);
+
+export var ManifestProcessor = {
+  get defaultDisplayMode() {
+    return "browser";
+  },
+  get displayModes() {
+    return displayModes;
+  },
+  get orientationTypes() {
+    return orientationTypes;
+  },
+  get textDirections() {
+    return textDirections;
+  },
+  // process() method processes JSON text into a clean manifest
+  // that conforms with the W3C specification. Takes an object
+  // expecting the following dictionary items:
+  //  * jsonText: the JSON string to be processed.
+  //  * manifestURL: the URL of the manifest, to resolve URLs.
+  //  * docURL: the URL of the owner doc, for security checks
+  //  * checkConformance: boolean. If true, collects any conformance
+  //    errors into a "moz_validation" property on the returned manifest.
+  process(aOptions) {
+    const {
+      jsonText,
+      manifestURL: aManifestURL,
+      docURL: aDocURL,
+      checkConformance,
+    } = aOptions;
+
+    // The errors get populated by the different process* functions.
+    const errors = [];
+
+    let rawManifest = {};
+    try {
+      rawManifest = JSON.parse(jsonText);
+    } catch (e) {
+      errors.push({ type: "json", error: e.message });
+    }
+    if (rawManifest === null) {
+      return null;
+    }
+    if (typeof rawManifest !== "object") {
+      const warn = domBundle.GetStringFromName("ManifestShouldBeObject");
+      errors.push({ warn });
+      rawManifest = {};
+    }
+    const manifestURL = new URL(aManifestURL);
+    const docURL = new URL(aDocURL);
+    const extractor = new ValueExtractor(errors, domBundle);
+    const imgObjProcessor = new ImageObjectProcessor(
+      errors,
+      extractor,
+      domBundle
+    );
+    const processedManifest = {
+      dir: processDirMember.call(this),
+      lang: processLangMember(),
+      start_url: processStartURLMember(),
+      display: processDisplayMember.call(this),
+      orientation: processOrientationMember.call(this),
+      name: processNameMember(),
+      icons: imgObjProcessor.process(rawManifest, manifestURL, "icons"),
+      short_name: processShortNameMember(),
+      theme_color: processThemeColorMember(),
+      background_color: processBackgroundColorMember(),
+    };
+    processedManifest.scope = processScopeMember();
+    processedManifest.id = processIdMember();
+    if (checkConformance) {
+      processedManifest.moz_validation = errors;
+      processedManifest.moz_manifest_url = manifestURL.href;
+    }
+    return processedManifest;
+
+    function processDirMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "dir",
+        expectedType: "string",
+        trim: true,
+      };
+      const value = extractor.extractValue(spec);
+      if (this.textDirections.has(value)) {
+        return value;
+      }
+      return "auto";
+    }
+
+    function processNameMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "name",
+        expectedType: "string",
+        trim: true,
+      };
+      return extractor.extractValue(spec);
+    }
+
+    function processShortNameMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "short_name",
+        expectedType: "string",
+        trim: true,
+      };
+      return extractor.extractValue(spec);
+    }
+
+    function processOrientationMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "orientation",
+        expectedType: "string",
+        trim: true,
+      };
+      const value = extractor.extractValue(spec);
+      if (
+        value &&
+        typeof value === "string" &&
+        this.orientationTypes.has(value.toLowerCase())
+      ) {
+        return value.toLowerCase();
+      }
+      return undefined;
+    }
+
+    function processDisplayMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "display",
+        expectedType: "string",
+        trim: true,
+      };
+      const value = extractor.extractValue(spec);
+      if (
+        value &&
+        typeof value === "string" &&
+        displayModes.has(value.toLowerCase())
+      ) {
+        return value.toLowerCase();
+      }
+      return this.defaultDisplayMode;
+    }
+
+    function processScopeMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "scope",
+        expectedType: "string",
+        trim: false,
+      };
+      let scopeURL;
+      const startURL = new URL(processedManifest.start_url);
+      const defaultScope = new URL(".", startURL).href;
+      const value = extractor.extractValue(spec);
+      if (value === undefined || value === "") {
+        return defaultScope;
+      }
+      try {
+        scopeURL = new URL(value, manifestURL);
+      } catch (e) {
+        const warn = domBundle.GetStringFromName("ManifestScopeURLInvalid");
+        errors.push({ warn });
+        return defaultScope;
+      }
+      if (scopeURL.origin !== docURL.origin) {
+        const warn = domBundle.GetStringFromName("ManifestScopeNotSameOrigin");
+        errors.push({ warn });
+        return defaultScope;
+      }
+      // If start URL is not within scope of scope URL:
+      if (
+        startURL.origin !== scopeURL.origin ||
+        startURL.pathname.startsWith(scopeURL.pathname) === false
+      ) {
+        const warn = domBundle.GetStringFromName(
+          "ManifestStartURLOutsideScope"
+        );
+        errors.push({ warn });
+        return defaultScope;
+      }
+      // Drop search params and fragment
+      // https://github.com/w3c/manifest/pull/961
+      scopeURL.hash = "";
+      scopeURL.search = "";
+      return scopeURL.href;
+    }
+
+    function processStartURLMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "start_url",
+        expectedType: "string",
+        trim: false,
+      };
+      const defaultStartURL = new URL(docURL).href;
+      const value = extractor.extractValue(spec);
+      if (value === undefined || value === "") {
+        return defaultStartURL;
+      }
+      let potentialResult;
+      try {
+        potentialResult = new URL(value, manifestURL);
+      } catch (e) {
+        const warn = domBundle.GetStringFromName("ManifestStartURLInvalid");
+        errors.push({ warn });
+        return defaultStartURL;
+      }
+      if (potentialResult.origin !== docURL.origin) {
+        const warn = domBundle.GetStringFromName(
+          "ManifestStartURLShouldBeSameOrigin"
+        );
+        errors.push({ warn });
+        return defaultStartURL;
+      }
+      return potentialResult.href;
+    }
+
+    function processThemeColorMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "theme_color",
+        expectedType: "string",
+        trim: true,
+      };
+      return extractor.extractColorValue(spec);
+    }
+
+    function processBackgroundColorMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "background_color",
+        expectedType: "string",
+        trim: true,
+      };
+      return extractor.extractColorValue(spec);
+    }
+
+    function processLangMember() {
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "lang",
+        expectedType: "string",
+        trim: true,
+      };
+      return extractor.extractLanguageValue(spec);
+    }
+
+    function processIdMember() {
+      // the start_url serves as the fallback, in case the id is not specified
+      // or in error. A start_url is assured.
+      const startURL = new URL(processedManifest.start_url);
+
+      const spec = {
+        objectName: "manifest",
+        object: rawManifest,
+        property: "id",
+        expectedType: "string",
+        trim: false,
+      };
+      const extractedValue = extractor.extractValue(spec);
+
+      if (typeof extractedValue !== "string" || extractedValue === "") {
+        return startURL.href;
+      }
+
+      let appId;
+      try {
+        appId = new URL(extractedValue, startURL.origin);
+      } catch {
+        const warn = domBundle.GetStringFromName("ManifestIdIsInvalid");
+        errors.push({ warn });
+        return startURL.href;
+      }
+
+      if (appId.origin !== startURL.origin) {
+        const warn = domBundle.GetStringFromName("ManifestIdNotSameOrigin");
+        errors.push({ warn });
+        return startURL.href;
+      }
+
+      return appId.href;
+    }
+  },
+};
diff --git a/dom/manifest/ValueExtractor.sys.mjs b/dom/manifest/ValueExtractor.sys.mjs
new file mode 100644
index 0000000000..d08cd24e1c
--- /dev/null
+++ b/dom/manifest/ValueExtractor.sys.mjs
@@ -0,0 +1,97 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+/*
+ * Helper functions extract values from manifest members
+ * and reports conformance errors.
+ */
+
+export class ValueExtractor {
+  constructor(errors, aBundle) {
+    this.errors = errors;
+    this.domBundle = aBundle;
+  }
+
+  /**
+   * @param options
+   *        The 'spec' object.
+   * @note  This function takes a 'spec' object and destructures it to extract
+   *        a value. If the value is of the wrong type, it warns the developer
+   *        and returns undefined.
+   *        expectedType: is the type of a JS primitive (string, number, etc.)
+   *        object: is the object from which to extract the value.
+   *        objectName: string used to construct the developer warning.
+   *        property: the name of the property being extracted.
+   *        throwTypeError: boolean, throw a TypeError if the type is incorrect.
+   *        trim: boolean, if the value should be trimmed (used by string type).
+   */
+  extractValue(options) {
+    const { expectedType, object, objectName, property, throwTypeError, trim } =
+      options;
+    const value = object[property];
+    const isArray = Array.isArray(value);
+
+    // We need to special-case "array", as it's not a JS primitive.
+    const type = isArray ? "array" : typeof value;
+    if (type !== expectedType) {
+      if (type !== "undefined") {
+        const warn = this.domBundle.formatStringFromName(
+          "ManifestInvalidType",
+          [objectName, property, expectedType]
+        );
+        this.errors.push({ warn });
+        if (throwTypeError) {
+          throw new TypeError(warn);
+        }
+      }
+      return undefined;
+    }
+
+    // Trim string and returned undefined if the empty string.
+    const shouldTrim = expectedType === "string" && value && trim;
+    if (shouldTrim) {
+      return value.trim() || undefined;
+    }
+    return value;
+  }
+
+  extractColorValue(spec) {
+    const value = this.extractValue(spec);
+    let color;
+    if (InspectorUtils.isValidCSSColor(value)) {
+      const rgba = InspectorUtils.colorToRGBA(value);
+      color =
+        "#" +
+        rgba.r.toString(16).padStart(2, "0") +
+        rgba.g.toString(16).padStart(2, "0") +
+        rgba.b.toString(16).padStart(2, "0") +
+        Math.round(rgba.a * 255)
+          .toString(16)
+          .padStart(2, "0");
+    } else if (value) {
+      const warn = this.domBundle.formatStringFromName(
+        "ManifestInvalidCSSColor",
+        [spec.property, value]
+      );
+      this.errors.push({ warn });
+    }
+    return color;
+  }
+
+  extractLanguageValue(spec) {
+    let langTag;
+    const value = this.extractValue(spec);
+    if (value !== undefined) {
+      try {
+        langTag = Intl.getCanonicalLocales(value)[0];
+      } catch (err) {
+        const warn = this.domBundle.formatStringFromName(
+          "ManifestLangIsInvalid",
+          [spec.property, value]
+        );
+        this.errors.push({ warn });
+      }
+    }
+    return langTag;
+  }
+}
diff --git a/dom/manifest/moz.build b/dom/manifest/moz.build
new file mode 100644
index 0000000000..c350a6aefb
--- /dev/null
+++ b/dom/manifest/moz.build
@@ -0,0 +1,21 @@
+# -*- 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "DOM: Core & HTML")
+
+EXTRA_JS_MODULES += [
+    "ImageObjectProcessor.sys.mjs",
+    "Manifest.sys.mjs",
+    "ManifestFinder.sys.mjs",
+    "ManifestIcons.sys.mjs",
+    "ManifestObtainer.sys.mjs",
+    "ManifestProcessor.sys.mjs",
+    "ValueExtractor.sys.mjs",
+]
+
+MOCHITEST_MANIFESTS += ["test/mochitest.ini"]
+BROWSER_CHROME_MANIFESTS += ["test/browser.ini"]
diff --git a/dom/manifest/test/blue-150.png b/dom/manifest/test/blue-150.png
new file mode 100644
index 0000000000..f4a62faddf
--- /dev/null
+++ b/dom/manifest/test/blue-150.png
diff --git a/dom/manifest/test/browser.ini b/dom/manifest/test/browser.ini
new file mode 100644
index 0000000000..8ea569b261
--- /dev/null
+++ b/dom/manifest/test/browser.ini
@@ -0,0 +1,18 @@
+[DEFAULT]
+support-files =
+  cookie_setter_with_credentials_cross_origin.html
+  cookie_setter_with_credentials.html
+  blue-150.png
+  cookie_checker.sjs
+  cookie_setter.html
+  file_testserver.sjs
+  manifestLoader.html
+  red-50.png
+  resource.sjs
+
+[browser_Manifest_install.js]
+skip-if = verify
+[browser_ManifestFinder_browserHasManifestLink.js]
+[browser_ManifestIcons_browserFetchIcon.js]
+[browser_ManifestObtainer_credentials.js]
+[browser_ManifestObtainer_obtain.js]
diff --git a/dom/manifest/test/browser_ManifestFinder_browserHasManifestLink.js b/dom/manifest/test/browser_ManifestFinder_browserHasManifestLink.js
new file mode 100644
index 0000000000..360c98220b
--- /dev/null
+++ b/dom/manifest/test/browser_ManifestFinder_browserHasManifestLink.js
@@ -0,0 +1,89 @@
+"use strict";
+const { ManifestFinder } = ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestFinder.sys.mjs"
+);
+const defaultURL = new URL(
+  "http://example.org/browser/dom/manifest/test/resource.sjs"
+);
+defaultURL.searchParams.set("Content-Type", "text/html; charset=utf-8");
+
+const tests = [
+  {
+    body: `
+    <link rel="manifesto" href='${defaultURL}?body={"name":"fail"}'>
+    <link rel="foo bar manifest bar test" href='${defaultURL}?body={"name":"value"}'>
+    <link rel="manifest" href='${defaultURL}?body={"name":"fail"}'>
+  `,
+    run(result) {
+      ok(result, "Document has a web manifest.");
+    },
+  },
+  {
+    body: `
+    <link rel="amanifista" href='${defaultURL}?body={"name":"fail"}'>
+    <link rel="foo bar manifesto bar test" href='${defaultURL}?body={"name":"pass-1"}'>
+    <link rel="manifesto" href='${defaultURL}?body={"name":"fail"}'>`,
+    run(result) {
+      ok(!result, "Document does not have a web manifest.");
+    },
+  },
+  {
+    body: `
+    <link rel="manifest" href="">
+    <link rel="manifest" href='${defaultURL}?body={"name":"fail"}'>`,
+    run(result) {
+      ok(!result, "Manifest link is has empty href.");
+    },
+  },
+  {
+    body: `
+    <link rel="manifest">
+    <link rel="manifest" href='${defaultURL}?body={"name":"fail"}'>`,
+    run(result) {
+      ok(!result, "Manifest link is missing.");
+    },
+  },
+];
+
+function makeTestURL({ body }) {
+  const url = new URL(defaultURL);
+  url.searchParams.set("body", encodeURIComponent(body));
+  return url.href;
+}
+
+/**
+ * Test basic API error conditions
+ */
+add_task(async function () {
+  const expected = "Invalid types should throw a TypeError.";
+  for (let invalidValue of [undefined, null, 1, {}, "test"]) {
+    try {
+      await ManifestFinder.contentManifestLink(invalidValue);
+      ok(false, expected);
+    } catch (e) {
+      is(e.name, "TypeError", expected);
+    }
+    try {
+      await ManifestFinder.browserManifestLink(invalidValue);
+      ok(false, expected);
+    } catch (e) {
+      is(e.name, "TypeError", expected);
+    }
+  }
+});
+
+add_task(async function () {
+  const runningTests = tests
+    .map(test => ({
+      gBrowser,
+      test,
+      url: makeTestURL(test),
+    }))
+    .map(tabOptions =>
+      BrowserTestUtils.withNewTab(tabOptions, async function (browser) {
+        const result = await ManifestFinder.browserHasManifestLink(browser);
+        tabOptions.test.run(result);
+      })
+    );
+  await Promise.all(runningTests);
+});
diff --git a/dom/manifest/test/browser_ManifestIcons_browserFetchIcon.js b/dom/manifest/test/browser_ManifestIcons_browserFetchIcon.js
new file mode 100644
index 0000000000..e56e1e25c2
--- /dev/null
+++ b/dom/manifest/test/browser_ManifestIcons_browserFetchIcon.js
@@ -0,0 +1,66 @@
+"use strict";
+
+Services.prefs.setBoolPref("dom.manifest.enabled", true);
+
+const { ManifestIcons } = ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestIcons.sys.mjs"
+);
+const { ManifestObtainer } = ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestObtainer.sys.mjs"
+);
+
+const defaultURL = new URL(
+  "https://example.org/browser/dom/manifest/test/resource.sjs"
+);
+defaultURL.searchParams.set("Content-Type", "application/manifest+json");
+
+const manifestMock = JSON.stringify({
+  icons: [
+    {
+      sizes: "50x50",
+      src: "red-50.png?Content-type=image/png",
+    },
+    {
+      sizes: "150x150",
+      src: "blue-150.png?Content-type=image/png",
+    },
+  ],
+});
+
+function makeTestURL() {
+  const url = new URL(defaultURL);
+  const body = `<link rel="manifest" href='${defaultURL}&body=${manifestMock}'>`;
+  url.searchParams.set("Content-Type", "text/html; charset=utf-8");
+  url.searchParams.set("body", encodeURIComponent(body));
+  return url.href;
+}
+
+function getIconColor(icon) {
+  return new Promise((resolve, reject) => {
+    const canvas = content.document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    const image = new content.Image();
+    image.onload = function () {
+      ctx.drawImage(image, 0, 0);
+      resolve(ctx.getImageData(1, 1, 1, 1).data);
+    };
+    image.onerror = function () {
+      reject(new Error("could not create image"));
+    };
+    image.src = icon;
+  });
+}
+
+add_task(async function () {
+  const tabOptions = { gBrowser, url: makeTestURL() };
+  await BrowserTestUtils.withNewTab(tabOptions, async function (browser) {
+    const manifest = await ManifestObtainer.browserObtainManifest(browser);
+    let icon = await ManifestIcons.browserFetchIcon(browser, manifest, 25);
+    let color = await SpecialPowers.spawn(browser, [icon], getIconColor);
+    is(color[0], 255, "Fetched red icon");
+
+    icon = await ManifestIcons.browserFetchIcon(browser, manifest, 500);
+    color = await SpecialPowers.spawn(browser, [icon], getIconColor);
+    is(color[2], 255, "Fetched blue icon");
+  });
+});
diff --git a/dom/manifest/test/browser_ManifestObtainer_credentials.js b/dom/manifest/test/browser_ManifestObtainer_credentials.js
new file mode 100644
index 0000000000..826ec24fc0
--- /dev/null
+++ b/dom/manifest/test/browser_ManifestObtainer_credentials.js
@@ -0,0 +1,45 @@
+"use strict";
+
+Services.prefs.setBoolPref("dom.manifest.enabled", true);
+
+const { ManifestObtainer } = ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestObtainer.sys.mjs"
+);
+
+// Don't send cookies
+add_task(async function () {
+  const testPath = "/browser/dom/manifest/test/cookie_setter.html";
+  const tabURL = `https://example.com${testPath}`;
+  const browser = BrowserTestUtils.addTab(gBrowser, tabURL).linkedBrowser;
+  await BrowserTestUtils.browserLoaded(browser);
+  const { short_name } = await ManifestObtainer.browserObtainManifest(browser);
+  is(short_name, "no cookie");
+  const tab = gBrowser.getTabForBrowser(browser);
+  gBrowser.removeTab(tab);
+});
+
+// Send cookies
+add_task(async function () {
+  const testPath =
+    "/browser/dom/manifest/test/cookie_setter_with_credentials.html";
+  const tabURL = `https://example.com${testPath}`;
+  const browser = BrowserTestUtils.addTab(gBrowser, tabURL).linkedBrowser;
+  await BrowserTestUtils.browserLoaded(browser);
+  const { short_name } = await ManifestObtainer.browserObtainManifest(browser);
+  is(short_name, "🍪");
+  const tab = gBrowser.getTabForBrowser(browser);
+  gBrowser.removeTab(tab);
+});
+
+// Cross origin - we go from example.com to example.org
+add_task(async function () {
+  const testPath =
+    "/browser/dom/manifest/test/cookie_setter_with_credentials_cross_origin.html";
+  const tabURL = `https://example.com${testPath}`;
+  const browser = BrowserTestUtils.addTab(gBrowser, tabURL).linkedBrowser;
+  await BrowserTestUtils.browserLoaded(browser);
+  const { short_name } = await ManifestObtainer.browserObtainManifest(browser);
+  is(short_name, "no cookie");
+  const tab = gBrowser.getTabForBrowser(browser);
+  gBrowser.removeTab(tab);
+});
diff --git a/dom/manifest/test/browser_ManifestObtainer_obtain.js b/dom/manifest/test/browser_ManifestObtainer_obtain.js
new file mode 100644
index 0000000000..a6d1dd6f23
--- /dev/null
+++ b/dom/manifest/test/browser_ManifestObtainer_obtain.js
@@ -0,0 +1,268 @@
+"use strict";
+
+Services.prefs.setBoolPref("dom.manifest.enabled", true);
+Services.prefs.setBoolPref("dom.security.https_first", false);
+
+const { ManifestObtainer } = ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestObtainer.sys.mjs"
+);
+const remoteURL =
+  "http://mochi.test:8888/browser/dom/manifest/test/resource.sjs";
+const defaultURL = new URL(
+  "http://example.org/browser/dom/manifest/test/resource.sjs"
+);
+defaultURL.searchParams.set("Content-Type", "text/html; charset=utf-8");
+requestLongerTimeout(4);
+
+const tests = [
+  // Fetch tests.
+  {
+    body: `<!-- no manifest in document -->`,
+    run(manifest) {
+      is(manifest, null, "Manifest without a href yields a null manifest.");
+    },
+  },
+  {
+    body: `<link rel="manifest">`,
+    run(manifest) {
+      is(manifest, null, "Manifest without a href yields a null manifest.");
+    },
+  },
+  {
+    body: `
+      <link rel="manifesto" href='resource.sjs?body={"name":"fail"}'>
+      <link rel="foo bar manifest bar test" href='resource.sjs?body={"name":"pass-1"}'>
+      <link rel="manifest" href='resource.sjs?body={"name":"fail"}'>`,
+    run(manifest) {
+      is(
+        manifest.name,
+        "pass-1",
+        "Manifest is first `link` where @rel contains token manifest."
+      );
+    },
+  },
+  {
+    body: `
+      <link rel="foo bar manifest bar test" href='resource.sjs?body={"name":"pass-2"}'>
+      <link rel="manifest" href='resource.sjs?body={"name":"fail"}'>
+      <link rel="manifest foo bar test" href='resource.sjs?body={"name":"fail"}'>`,
+    run(manifest) {
+      is(
+        manifest.name,
+        "pass-2",
+        "Manifest is first `link` where @rel contains token manifest."
+      );
+    },
+  },
+  {
+    body: `<link rel="manifest" href='${remoteURL}?body={"name":"pass-3"}'>`,
+    run(err) {
+      is(
+        err.name,
+        "TypeError",
+        "By default, manifest cannot load cross-origin."
+      );
+    },
+  },
+  // CORS Tests.
+  {
+    get body() {
+      const body = 'body={"name": "pass-4"}';
+      const CORS = `Access-Control-Allow-Origin=${defaultURL.origin}`;
+      const link = `<link
+        crossorigin=anonymous
+        rel="manifest"
+        href='${remoteURL}?${body}&${CORS}'>`;
+      return link;
+    },
+    run(manifest) {
+      is(manifest.name, "pass-4", "CORS enabled, manifest must be fetched.");
+    },
+  },
+  {
+    get body() {
+      const body = 'body={"name": "fail"}';
+      const CORS = "Access-Control-Allow-Origin=http://not-here";
+      const link = `<link
+        crossorigin
+        rel="manifest"
+        href='${remoteURL}?${body}&${CORS}'>`;
+      return link;
+    },
+    run(err) {
+      is(
+        err.name,
+        "TypeError",
+        "Fetch blocked by CORS - origin does not match."
+      );
+    },
+  },
+  {
+    body: `<link rel="manifest" href='about:whatever'>`,
+    run(err) {
+      is(
+        err.name,
+        "TypeError",
+        "Trying to load from about:whatever is TypeError."
+      );
+    },
+  },
+  {
+    body: `<link rel="manifest" href='file://manifest'>`,
+    run(err) {
+      is(
+        err.name,
+        "TypeError",
+        "Trying to load from file://whatever is a TypeError."
+      );
+    },
+  },
+  // URL parsing tests
+  {
+    body: `<link rel="manifest" href='http://[12.1212.21.21.12.21.12]'>`,
+    run(err) {
+      is(err.name, "TypeError", "Trying to load invalid URL is a TypeError.");
+    },
+  },
+];
+
+function makeTestURL({ body }) {
+  const url = new URL(defaultURL);
+  url.searchParams.set("body", encodeURIComponent(body));
+  return url.href;
+}
+
+add_task(async function () {
+  const promises = tests
+    .map(test => ({
+      gBrowser,
+      testRunner: testObtainingManifest(test),
+      url: makeTestURL(test),
+    }))
+    .reduce((collector, tabOpts) => {
+      const promise = BrowserTestUtils.withNewTab(tabOpts, tabOpts.testRunner);
+      collector.push(promise);
+      return collector;
+    }, []);
+
+  await Promise.all(promises);
+
+  function testObtainingManifest(aTest) {
+    return async function (aBrowser) {
+      try {
+        const manifest = await ManifestObtainer.browserObtainManifest(aBrowser);
+        aTest.run(manifest);
+      } catch (e) {
+        aTest.run(e);
+      }
+    };
+  }
+});
+
+add_task(async () => {
+  // This loads a generic html page.
+  const url = new URL(defaultURL);
+  // The body get injected into the page on the server.
+  const body = `<link rel="manifest" href='resource.sjs?body={"name": "conformance check"}'>`;
+  url.searchParams.set("body", encodeURIComponent(body));
+
+  // Let's open a tab!
+  const tabOpts = {
+    gBrowser,
+    url: url.href,
+  };
+  // Let's do the test
+  await BrowserTestUtils.withNewTab(tabOpts, async aBrowser => {
+    const obtainerOpts = {
+      checkConformance: true, // gives us back "moz_manifest_url" member
+    };
+    const manifest = await ManifestObtainer.browserObtainManifest(
+      aBrowser,
+      obtainerOpts
+    );
+    is(manifest.name, "conformance check");
+    ok("moz_manifest_url" in manifest, "Has a moz_manifest_url member");
+    const testString = defaultURL.origin + defaultURL.pathname;
+    ok(
+      manifest.moz_manifest_url.startsWith(testString),
+      `Expect to start with with the testString, but got ${manifest.moz_manifest_url} instead,`
+    );
+    // Clean up!
+    gBrowser.removeTab(gBrowser.getTabForBrowser(aBrowser));
+  });
+});
+
+/*
+ * e10s race condition tests
+ * Open a bunch of tabs and load manifests
+ * in each tab. They should all return pass.
+ */
+add_task(async function () {
+  const defaultPath = "/browser/dom/manifest/test/manifestLoader.html";
+  const tabURLs = [
+    `http://example.com:80${defaultPath}`,
+    `http://example.org:80${defaultPath}`,
+    `http://example.org:8000${defaultPath}`,
+    `http://mochi.test:8888${defaultPath}`,
+    `http://sub1.test1.example.com:80${defaultPath}`,
+    `http://sub1.test1.example.org:80${defaultPath}`,
+    `http://sub1.test1.example.org:8000${defaultPath}`,
+    `http://sub1.test1.mochi.test:8888${defaultPath}`,
+    `http://sub1.test2.example.com:80${defaultPath}`,
+    `http://sub1.test2.example.org:80${defaultPath}`,
+    `http://sub1.test2.example.org:8000${defaultPath}`,
+    `http://sub2.test1.example.com:80${defaultPath}`,
+    `http://sub2.test1.example.org:80${defaultPath}`,
+    `http://sub2.test1.example.org:8000${defaultPath}`,
+    `http://sub2.test2.example.com:80${defaultPath}`,
+    `http://sub2.test2.example.org:80${defaultPath}`,
+    `http://sub2.test2.example.org:8000${defaultPath}`,
+    `http://sub2.xn--lt-uia.mochi.test:8888${defaultPath}`,
+    `http://test1.example.com:80${defaultPath}`,
+    `http://test1.example.org:80${defaultPath}`,
+    `http://test1.example.org:8000${defaultPath}`,
+    `http://test1.mochi.test:8888${defaultPath}`,
+    `http://test2.example.com:80${defaultPath}`,
+    `http://test2.example.org:80${defaultPath}`,
+    `http://test2.example.org:8000${defaultPath}`,
+    `http://test2.mochi.test:8888${defaultPath}`,
+    `http://test:80${defaultPath}`,
+    `http://www.example.com:80${defaultPath}`,
+  ];
+  // Open tabs an collect corresponding browsers
+  let browsers = tabURLs.map(
+    url => BrowserTestUtils.addTab(gBrowser, url).linkedBrowser
+  );
+
+  // Once all the pages have loaded, run a bunch of tests in "parallel".
+  await Promise.all(
+    (function* () {
+      for (let browser of browsers) {
+        yield BrowserTestUtils.browserLoaded(browser);
+      }
+    })()
+  );
+  // Flood random browsers with requests. Once promises settle, check that
+  // responses all pass.
+  const results = await Promise.all(
+    (function* () {
+      for (let browser of randBrowsers(browsers, 50)) {
+        yield ManifestObtainer.browserObtainManifest(browser);
+      }
+    })()
+  );
+  const pass = results.every(manifest => manifest.name === "pass");
+  ok(pass, "Expect every manifest to have name equal to `pass`.");
+  // cleanup
+  browsers
+    .map(browser => gBrowser.getTabForBrowser(browser))
+    .forEach(tab => gBrowser.removeTab(tab));
+
+  // Helper generator, spits out random browsers
+  function* randBrowsers(aBrowsers, aMax) {
+    for (let i = 0; i < aMax; i++) {
+      const randNum = Math.round(Math.random() * (aBrowsers.length - 1));
+      yield aBrowsers[randNum];
+    }
+  }
+});
diff --git a/dom/manifest/test/browser_Manifest_install.js b/dom/manifest/test/browser_Manifest_install.js
new file mode 100644
index 0000000000..d3b949be19
--- /dev/null
+++ b/dom/manifest/test/browser_Manifest_install.js
@@ -0,0 +1,58 @@
+"use strict";
+
+const { Manifests } = ChromeUtils.importESModule(
+  "resource://gre/modules/Manifest.sys.mjs"
+);
+
+const defaultURL = new URL(
+  "http://example.org/browser/dom/manifest/test/resource.sjs"
+);
+defaultURL.searchParams.set("Content-Type", "application/manifest+json");
+
+const manifestMock = JSON.stringify({
+  short_name: "hello World",
+  scope: "/browser/",
+});
+const manifestUrl = `${defaultURL}&body=${manifestMock}`;
+
+function makeTestURL() {
+  const url = new URL(defaultURL);
+  const body = `<link rel="manifest" href='${manifestUrl}'>`;
+  url.searchParams.set("Content-Type", "text/html; charset=utf-8");
+  url.searchParams.set("body", encodeURIComponent(body));
+  return url.href;
+}
+
+add_task(async function () {
+  const tabOptions = { gBrowser, url: makeTestURL() };
+
+  await BrowserTestUtils.withNewTab(tabOptions, async function (browser) {
+    let manifest = await Manifests.getManifest(browser, manifestUrl);
+    is(manifest.installed, false, "We haven't installed this manifest yet");
+
+    await manifest.install(browser);
+    is(manifest.name, "hello World", "Manifest has correct name");
+    is(manifest.installed, true, "Manifest is installed");
+    is(manifest.url, manifestUrl, "has correct url");
+    is(manifest.browser, browser, "has correct browser");
+
+    manifest = await Manifests.getManifest(browser, manifestUrl);
+    is(manifest.installed, true, "New instances are installed");
+
+    manifest = await Manifests.getManifest(browser);
+    is(manifest.installed, true, "Will find manifest without being given url");
+
+    let foundManifest = Manifests.findManifestUrl(
+      "http://example.org/browser/dom/"
+    );
+    is(foundManifest, manifestUrl, "Finds manifests within scope");
+
+    foundManifest = Manifests.findManifestUrl("http://example.org/");
+    is(foundManifest, null, "Does not find manifests outside scope");
+  });
+  // Get the cached one now
+  await BrowserTestUtils.withNewTab(tabOptions, async browser => {
+    const manifest = await Manifests.getManifest(browser, manifestUrl);
+    is(manifest.browser, browser, "has updated browser object");
+  });
+});
diff --git a/dom/manifest/test/common.js b/dom/manifest/test/common.js
new file mode 100644
index 0000000000..50f27c119a
--- /dev/null
+++ b/dom/manifest/test/common.js
@@ -0,0 +1,139 @@
+/**
+ * Common infrastructure for manifest tests.
+ **/
+"use strict";
+const { ManifestProcessor } = SpecialPowers.ChromeUtils.importESModule(
+  "resource://gre/modules/ManifestProcessor.sys.mjs"
+);
+const processor = ManifestProcessor;
+const manifestURL = new URL(document.location.origin + "/manifest.json");
+const docURL = document.location;
+const seperators =
+  "\u2028\u2029\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000";
+const lineTerminators = "\u000D\u000A\u2028\u2029";
+const whiteSpace = `${seperators}${lineTerminators}`;
+const typeTests = [1, null, {}, [], false];
+const data = {
+  jsonText: "{}",
+  manifestURL,
+  docURL,
+};
+
+const validThemeColors = [
+  ["maroon", "#800000ff"],
+  ["#f00", "#ff0000ff"],
+  ["#ff0000", "#ff0000ff"],
+  ["rgb(255,0,0)", "#ff0000ff"],
+  ["rgb(255,0,0,1)", "#ff0000ff"],
+  ["rgb(255,0,0,1.0)", "#ff0000ff"],
+  ["rgb(255,0,0,100%)", "#ff0000ff"],
+  ["rgb(255 0 0)", "#ff0000ff"],
+  ["rgb(255 0 0 / 1)", "#ff0000ff"],
+  ["rgb(255 0 0 / 1.0)", "#ff0000ff"],
+  ["rgb(255 0 0 / 100%)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%, 1)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%, 1.0)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%, 100%)", "#ff0000ff"],
+  ["rgb(100% 0% 0%)", "#ff0000ff"],
+  ["rgb(100% 0% 0% / 1)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%, 1.0)", "#ff0000ff"],
+  ["rgb(100%, 0%, 0%, 100%)", "#ff0000ff"],
+  ["rgb(300,0,0)", "#ff0000ff"],
+  ["rgb(300 0 0)", "#ff0000ff"],
+  ["rgb(255,-10,0)", "#ff0000ff"],
+  ["rgb(110%, 0%, 0%)", "#ff0000ff"],
+  ["rgba(255,0,0)", "#ff0000ff"],
+  ["rgba(255,0,0,1)", "#ff0000ff"],
+  ["rgba(255 0 0 / 1)", "#ff0000ff"],
+  ["rgba(100%,0%,0%,1)", "#ff0000ff"],
+  ["rgba(0,0,255,0.5)", "#0000ff80"],
+  ["rgba(100%, 50%, 0%, 0.1)", "#ff80001a"],
+  ["hsl(120, 100%, 50%)", "#00ff00ff"],
+  ["hsl(120 100% 50%)", "#00ff00ff"],
+  ["hsl(120, 100%, 50%, 1.0)", "#00ff00ff"],
+  ["hsl(120 100% 50% / 1.0)", "#00ff00ff"],
+  ["hsla(120, 100%, 50%)", "#00ff00ff"],
+  ["hsla(120 100% 50%)", "#00ff00ff"],
+  ["hsla(120, 100%, 50%, 1.0)", "#00ff00ff"],
+  ["hsla(120 100% 50% / 1.0)", "#00ff00ff"],
+  ["hsl(120deg, 100%, 50%)", "#00ff00ff"],
+  ["hsl(133.33333333grad, 100%, 50%)", "#00ff00ff"],
+  ["hsl(2.0943951024rad, 100%, 50%)", "#00ff00ff"],
+  ["hsl(0.3333333333turn, 100%, 50%)", "#00ff00ff"],
+];
+
+function setupManifest(key, value) {
+  const manifest = {};
+  manifest[key] = value;
+  data.jsonText = JSON.stringify(manifest);
+}
+
+function testValidColors(key) {
+  validThemeColors.forEach(item => {
+    const [manifest_color, parsed_color] = item;
+    setupManifest(key, manifest_color);
+    const result = processor.process(data);
+
+    is(
+      result[key],
+      parsed_color,
+      `Expect ${key} to be returned for ${manifest_color}`
+    );
+  });
+
+  // Trim tests
+  validThemeColors.forEach(item => {
+    const [manifest_color, parsed_color] = item;
+    const expandedThemeColor = `${seperators}${lineTerminators}${manifest_color}${lineTerminators}${seperators}`;
+    setupManifest(key, expandedThemeColor);
+    const result = processor.process(data);
+
+    is(
+      result[key],
+      parsed_color,
+      `Expect trimmed ${key} to be returned for ${manifest_color}`
+    );
+  });
+}
+
+const invalidThemeColors = [
+  "marooon",
+  "f000000",
+  "#ff00000",
+  "rgb(100, 0%, 0%)",
+  "rgb(255,0)",
+  "rbg(255,-10,0)",
+  "rgb(110, 0%, 0%)",
+  "(255,0,0) }",
+  "rgba(255)",
+  " rgb(100%,0%,0%) }",
+  "hsl(120, 100%, 50)",
+  "hsl(120, 100%, 50.0)",
+  "hsl 120, 100%, 50%",
+  "hsla{120, 100%, 50%, 1}",
+];
+
+function testInvalidColors(key) {
+  typeTests.forEach(type => {
+    setupManifest(key, type);
+    const result = processor.process(data);
+
+    is(
+      result[key],
+      undefined,
+      `Expect non-string ${key} to be undefined: ${typeof type}.`
+    );
+  });
+
+  invalidThemeColors.forEach(manifest_color => {
+    setupManifest(key, manifest_color);
+    const result = processor.process(data);
+
+    is(
+      result[key],
+      undefined,
+      `Expect ${key} to be undefined: ${manifest_color}.`
+    );
+  });
+}
diff --git a/dom/manifest/test/cookie_checker.sjs b/dom/manifest/test/cookie_checker.sjs
new file mode 100644
index 0000000000..fa5df00d44
--- /dev/null
+++ b/dom/manifest/test/cookie_checker.sjs
@@ -0,0 +1,22 @@
+"use strict";
+let { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+
+function handleRequest(request, response) {
+  response.setStatusLine(request.httpVersion, 200);
+  // avoid confusing cache behaviors
+  response.setHeader("Cache-Control", "no-cache", false);
+  response.setHeader("Content-Type", "application/json", false);
+
+  // CORS stuff
+  const origin = request.hasHeader("Origin")
+    ? request.getHeader("Origin")
+    : null;
+  if (origin) {
+    response.setHeader("Access-Control-Allow-Origin", origin);
+    response.setHeader("Access-Control-Allow-Credentials", "true");
+  }
+  const short_name = request.hasHeader("Cookie")
+    ? request.getHeader("Cookie")
+    : "no cookie";
+  response.write(JSON.stringify({ short_name }));
+}
diff --git a/dom/manifest/test/cookie_setter.html b/dom/manifest/test/cookie_setter.html
new file mode 100644
index 0000000000..d8f412fbcb
--- /dev/null
+++ b/dom/manifest/test/cookie_setter.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script>
+	document.cookie = "🍪";
+</script>
+<link
+	rel="manifest"
+	href="cookie_checker.sjs">
diff --git a/dom/manifest/test/cookie_setter_with_credentials.html b/dom/manifest/test/cookie_setter_with_credentials.html
new file mode 100644
index 0000000000..0d721b55ef
--- /dev/null
+++ b/dom/manifest/test/cookie_setter_with_credentials.html
@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script>
+	document.cookie = "🍪";
+</script>
+<link rel="manifest" href="cookie_checker.sjs" crossorigin="use-credentials"`>
diff --git a/dom/manifest/test/cookie_setter_with_credentials_cross_origin.html b/dom/manifest/test/cookie_setter_with_credentials_cross_origin.html
new file mode 100644
index 0000000000..6d1c4045c3
--- /dev/null
+++ b/dom/manifest/test/cookie_setter_with_credentials_cross_origin.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<h1>Cross origin cookie sender</h1>
+<script>
+	document.cookie = "🍪";
+</script>
+<!--
+  This is loaded from "example.com", which then loads
+  the manifest from "example.org".
+-->
+<link
+  rel="manifest"
+  href="https://example.org/browser/dom/manifest/test/cookie_checker.sjs"
+  crossorigin="use-credentials">
diff --git a/dom/manifest/test/file_testserver.sjs b/dom/manifest/test/file_testserver.sjs
new file mode 100644
index 0000000000..bcceb15504
--- /dev/null
+++ b/dom/manifest/test/file_testserver.sjs
@@ -0,0 +1,55 @@
+"use strict";
+let { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+Cu.importGlobalProperties(["URLSearchParams"]);
+
+function loadHTMLFromFile(path) {
+  // Load the HTML to return in the response from file.
+  // Since it's relative to the cwd of the test runner, we start there and
+  // append to get to the actual path of the file.
+  const testHTMLFile = Services.dirsvc.get("CurWorkD", Ci.nsIFile);
+
+  const testHTMLFileStream = Cc[
+    "@mozilla.org/network/file-input-stream;1"
+  ].createInstance(Ci.nsIFileInputStream);
+
+  path
+    .split("/")
+    .filter(path_1 => path_1)
+    .reduce((file, path_2) => {
+      testHTMLFile.append(path_2);
+      return testHTMLFile;
+    }, testHTMLFile);
+  testHTMLFileStream.init(testHTMLFile, -1, 0, 0);
+  const isAvailable = testHTMLFileStream.available();
+  return NetUtil.readInputStreamToString(testHTMLFileStream, isAvailable);
+}
+
+function handleRequest(request, response) {
+  const query = new URLSearchParams(request.queryString);
+
+  // avoid confusing cache behaviors
+  response.setHeader("Cache-Control", "no-cache", false);
+
+  // Deliver the CSP policy encoded in the URL
+  if (query.has("csp")) {
+    response.setHeader("Content-Security-Policy", query.get("csp"), false);
+  }
+
+  // Deliver the CSPRO policy encoded in the URL
+  if (query.has("cspro")) {
+    response.setHeader(
+      "Content-Security-Policy-Report-Only",
+      query.get("cspro"),
+      false
+    );
+  }
+
+  // Deliver the CORS header in the URL
+  if (query.has("cors")) {
+    response.setHeader("Access-Control-Allow-Origin", query.get("cors"), false);
+  }
+
+  // Send HTML to test allowed/blocked behaviors
+  response.setHeader("Content-Type", "text/html", false);
+  response.write(loadHTMLFromFile(query.get("file")));
+}
diff --git a/dom/manifest/test/icon.png b/dom/manifest/test/icon.png
new file mode 100644
index 0000000000..bb87f783b7
--- /dev/null
+++ b/dom/manifest/test/icon.png
diff --git a/dom/manifest/test/manifestLoader.html b/dom/manifest/test/manifestLoader.html
new file mode 100644
index 0000000000..e244260902
--- /dev/null
+++ b/dom/manifest/test/manifestLoader.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<meta charset=utf-8>
+<!--
+Uses resource.sjs to load a Web Manifest that can be loaded cross-origin.
+-->
+<link rel="manifest" href='resource.sjs?body={"name":"pass"}&amp;Access-Control-Allow-Origin=*'>
+<h1>Manifest loader</h1>
+<p>Uses resource.sjs to load a Web Manifest that can be loaded cross-origin. The manifest looks like this:</p>
+<pre>
+{
+	"name":"pass"
+}
+</pre>
diff --git a/dom/manifest/test/mochitest.ini b/dom/manifest/test/mochitest.ini
new file mode 100644
index 0000000000..73d7a65787
--- /dev/null
+++ b/dom/manifest/test/mochitest.ini
@@ -0,0 +1,24 @@
+[DEFAULT]
+support-files =
+  common.js
+  resource.sjs
+  manifestLoader.html
+  file_testserver.sjs
+[test_ImageObjectProcessor_purpose.html]
+[test_ImageObjectProcessor_sizes.html]
+[test_ImageObjectProcessor_src.html]
+[test_ImageObjectProcessor_type.html]
+[test_link_relList_supports_manifest.html]
+[test_ManifestProcessor_background_color.html]
+[test_ManifestProcessor_dir.html]
+[test_ManifestProcessor_display.html]
+[test_ManifestProcessor_icons.html]
+[test_ManifestProcessor_id.html]
+[test_ManifestProcessor_JSON.html]
+[test_ManifestProcessor_lang.html]
+[test_ManifestProcessor_name_and_short_name.html]
+[test_ManifestProcessor_orientation.html]
+[test_ManifestProcessor_scope.html]
+[test_ManifestProcessor_start_url.html]
+[test_ManifestProcessor_theme_color.html]
+[test_ManifestProcessor_warnings.html]
diff --git a/dom/manifest/test/red-50.png b/dom/manifest/test/red-50.png
new file mode 100644
index 0000000000..e2ce365c3c
--- /dev/null
+++ b/dom/manifest/test/red-50.png
diff --git a/dom/manifest/test/resource.sjs b/dom/manifest/test/resource.sjs
new file mode 100644
index 0000000000..56deaa61d7
--- /dev/null
+++ b/dom/manifest/test/resource.sjs
@@ -0,0 +1,85 @@
+/* Generic responder that composes a response from
+ * the query string of a request.
+ *
+ * It reserves some special prop names:
+ *  - body: get's used as the response body
+ *  - statusCode: override the 200 OK response code
+ *    (response text is set automatically)
+ *
+ * Any property names it doesn't know about get converted into
+ * HTTP headers.
+ *
+ * For example:
+ *  http://test/resource.sjs?Content-Type=text/html&body=<h1>hello</h1>&Hello=hi
+ *
+ * Outputs:
+ * HTTP/1.1 200 OK
+ * Content-Type: text/html
+ * Hello: hi
+ * <h1>hello</h1>
+ */
+//global handleRequest
+"use strict";
+Cu.importGlobalProperties(["URLSearchParams"]);
+const HTTPStatus = new Map([
+  [100, "Continue"],
+  [101, "Switching Protocol"],
+  [200, "OK"],
+  [201, "Created"],
+  [202, "Accepted"],
+  [203, "Non-Authoritative Information"],
+  [204, "No Content"],
+  [205, "Reset Content"],
+  [206, "Partial Content"],
+  [300, "Multiple Choice"],
+  [301, "Moved Permanently"],
+  [302, "Found"],
+  [303, "See Other"],
+  [304, "Not Modified"],
+  [305, "Use Proxy"],
+  [306, "unused"],
+  [307, "Temporary Redirect"],
+  [308, "Permanent Redirect"],
+  [400, "Bad Request"],
+  [401, "Unauthorized"],
+  [402, "Payment Required"],
+  [403, "Forbidden"],
+  [404, "Not Found"],
+  [405, "Method Not Allowed"],
+  [406, "Not Acceptable"],
+  [407, "Proxy Authentication Required"],
+  [408, "Request Timeout"],
+  [409, "Conflict"],
+  [410, "Gone"],
+  [411, "Length Required"],
+  [412, "Precondition Failed"],
+  [413, "Request Entity Too Large"],
+  [414, "Request-URI Too Long"],
+  [415, "Unsupported Media Type"],
+  [416, "Requested Range Not Satisfiable"],
+  [417, "Expectation Failed"],
+  [500, "Internal Server Error"],
+  [501, "Not Implemented"],
+  [502, "Bad Gateway"],
+  [503, "Service Unavailable"],
+  [504, "Gateway Timeout"],
+  [505, "HTTP Version Not Supported"],
+]);
+
+function handleRequest(request, response) {
+  const queryMap = new URLSearchParams(request.queryString);
+  if (queryMap.has("statusCode")) {
+    let statusCode = parseInt(queryMap.get("statusCode"));
+    let statusText = HTTPStatus.get(statusCode);
+    queryMap.delete("statusCode");
+    response.setStatusLine("1.1", statusCode, statusText);
+  }
+  if (queryMap.has("body")) {
+    let body = queryMap.get("body") || "";
+    queryMap.delete("body");
+    response.write(decodeURIComponent(body));
+  }
+  for (let [key, value] of queryMap.entries()) {
+    response.setHeader(key, value);
+  }
+}
diff --git a/dom/manifest/test/test_ImageObjectProcessor_purpose.html b/dom/manifest/test/test_ImageObjectProcessor_purpose.html
new file mode 100644
index 0000000000..386c4566d4
--- /dev/null
+++ b/dom/manifest/test/test_ImageObjectProcessor_purpose.html
@@ -0,0 +1,120 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug </title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+    /**
+     * Image object's purpose member
+     * https://w3c.github.io/manifest/#purpose-member
+     **/
+
+    "use strict";
+    const testManifest = {
+      icons: [{
+        src: "test",
+      }],
+    };
+
+    const invalidPurposeTypes = [
+      [],
+      123,
+      {},
+      null,
+    ]
+
+    invalidPurposeTypes.forEach(invalidType => {
+      const expected = `Invalid types get treated as 'any'.`;
+      testManifest.icons[0].purpose = invalidType;
+      data.jsonText = JSON.stringify(testManifest);
+      const result = processor.process(data);
+      is(result.icons.length, 1, expected);
+      is(result.icons[0].purpose.length, 1, expected);
+      is(result.icons[0].purpose[0], "any", expected);
+    });
+
+    const invalidPurposes = [
+      "not-known-test-purpose",
+      "invalid-purpose invalid-purpose",
+      "no-purpose invalid-purpose some-other-non-valid-purpose",
+    ];
+
+    invalidPurposes.forEach(invalidPurpose => {
+      const expected = `Expect invalid purposes to invalidate the icon.`;
+      testManifest.icons[0].purpose = invalidPurpose;
+      data.jsonText = JSON.stringify(testManifest);
+      const result = processor.process(data);
+      is(result.icons.length, 0, expected);
+    });
+
+    const mixedMaskableAndInvalidPurposes = [
+      "not-known-test-purpose maskable",
+      "maskable invalid-purpose invalid-purpose",
+      "no-purpose invalid-purpose maskable some-other-non-valid-purpose",
+    ];
+
+    mixedMaskableAndInvalidPurposes.forEach(mixedPurpose => {
+      const expected = `Expect on 'maskable' to remain.`;
+      testManifest.icons[0].purpose = mixedPurpose;
+      data.jsonText = JSON.stringify(testManifest);
+      const result = processor.process(data);
+      is(result.icons.length, 1, expected);
+      is(result.icons[0].purpose.join(), "maskable", expected);
+    });
+
+    const mixedMonochromeAndInvalidPurposes = [
+      "not-known-test-purpose monochrome",
+      "monochrome invalid-purpose invalid-purpose",
+      "no-purpose invalid-purpose monochrome some-other-non-valid-purpose",
+    ];
+
+    mixedMonochromeAndInvalidPurposes.forEach(mixedPurpose => {
+      const expected = `Expect on 'monochrome' to remain.`;
+      testManifest.icons[0].purpose = mixedPurpose;
+      data.jsonText = JSON.stringify(testManifest);
+      const result = processor.process(data);
+      is(result.icons.length, 1, expected);
+      is(result.icons[0].purpose.join(), "monochrome", expected);
+    });
+
+    const validPurposes = [
+      "maskable",
+      "monochrome",
+      "any",
+      "any maskable",
+      "maskable any",
+      "any monochrome",
+      "monochrome any",
+      "maskable monochrome any",
+      "monochrome maskable"
+    ];
+
+    validPurposes.forEach(purpose => {
+      testManifest.icons[0].purpose = purpose;
+      data.jsonText = JSON.stringify(testManifest);
+      var manifest = processor.process(data);
+      is(manifest.icons[0].purpose.join(" "), purpose, `Expected "${purpose}" as purpose.`);
+    });
+
+    const validWhiteSpace = [
+      "",
+      whiteSpace, // defined in common.js
+      `${whiteSpace}any`,
+      `any${whiteSpace}`,
+      `${whiteSpace}any${whiteSpace}`,
+    ];
+
+    validWhiteSpace.forEach(purpose => {
+      testManifest.icons[0].purpose = purpose;
+      data.jsonText = JSON.stringify(testManifest);
+      var manifest = processor.process(data);
+      is(manifest.icons[0].purpose.join(), "any");
+    });
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ImageObjectProcessor_sizes.html b/dom/manifest/test/test_ImageObjectProcessor_sizes.html
new file mode 100644
index 0000000000..9418b44118
--- /dev/null
+++ b/dom/manifest/test/test_ImageObjectProcessor_sizes.html
@@ -0,0 +1,88 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * Image object's sizes member
+ * https://w3c.github.io/manifest/#sizes-member
+ **/
+"use strict";
+var validSizes = [{
+  test: "16x16",
+  expect: ["16x16"],
+}, {
+  test: "hello 16x16 16x16",
+  expect: ["16x16"],
+}, {
+  test: "32x32 16 48x48 12",
+  expect: ["32x32", "48x48"],
+}, {
+  test: `${whiteSpace}128x128${whiteSpace}512x512 8192x8192 32768x32768${whiteSpace}`,
+  expect: ["128x128", "512x512", "8192x8192", "32768x32768"],
+}, {
+  test: "any",
+  expect: ["any"],
+}, {
+  test: "Any",
+  expect: ["Any"],
+}, {
+  test: "16x32",
+  expect: ["16x32"],
+}, {
+  test: "17x33",
+  expect: ["17x33"],
+}, {
+  test: "32x32 32x32",
+  expect: ["32x32"],
+}, {
+  test: "32X32",
+  expect: ["32X32"],
+}, {
+  test: "any 32x32",
+  expect: ["any", "32x32"],
+}];
+
+var testIcon = {
+  icons: [{
+    src: "test",
+    sizes: undefined,
+  }],
+};
+
+validSizes.forEach(({test, expect}) => {
+  testIcon.icons[0].sizes = test;
+  data.jsonText = JSON.stringify(testIcon);
+  var result = processor.process(data);
+  var sizes = result.icons[0].sizes;
+  var expected = `Expect sizes to equal ${expect.join(" ")}`;
+  is(sizes.join(" "), expect.join(" "), expected);
+});
+
+var invalidSizes = ["invalid", "", " ", "16 x 16", "32", "21", "16xx16", "16 x x 6"];
+invalidSizes.forEach((invalidSize) => {
+  var expected = "Expect invalid sizes to return undefined.";
+  testIcon.icons[0].sizes = invalidSize;
+  data.jsonText = JSON.stringify(testIcon);
+  var result = processor.process(data);
+  var sizes = result.icons[0].sizes;
+  is(sizes, undefined, expected);
+});
+
+typeTests.forEach((type) => {
+  var expected = `Expect non-string sizes ${typeof type} to be undefined.`;
+  testIcon.icons[0].sizes = type;
+  data.jsonText = JSON.stringify(testIcon);
+  var result = processor.process(data);
+  var sizes = result.icons[0].sizes;
+  is(sizes, undefined, expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ImageObjectProcessor_src.html b/dom/manifest/test/test_ImageObjectProcessor_src.html
new file mode 100644
index 0000000000..8d17c3048f
--- /dev/null
+++ b/dom/manifest/test/test_ImageObjectProcessor_src.html
@@ -0,0 +1,110 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * Image object's src member
+ * https://w3c.github.io/manifest/#src-member
+ **/
+"use strict";
+
+var noSrc = {
+  icons: [{}, {
+    src: [],
+  }, {
+    src: {},
+  }, {
+    src: null,
+  }, {
+    type: "image/jpg",
+  }, {
+    sizes: "1x1,2x2",
+  }, {
+    sizes: "any",
+    type: "image/jpg",
+  }],
+};
+
+var expected = `Expect icons without a src prop to be filtered out.`;
+data.jsonText = JSON.stringify(noSrc);
+var result = processor.process(data);
+is(result.icons.length, 0, expected);
+
+var invalidSrc = {
+  icons: [{
+    src: null,
+  }, {
+    src: 1,
+  }, {
+    src: [],
+  }, {
+    src: {},
+  }, {
+    src: true,
+  }, {
+    src: "",
+  }],
+};
+
+expected = `Expect icons with invalid src prop to be filtered out.`;
+data.jsonText = JSON.stringify(invalidSrc);
+result = processor.process(data);
+is(result.icons.length, 0, expected);
+
+expected = `Expect icon's src to be a string.`;
+var withSrc = {
+  icons: [{
+    src: "pass",
+  }],
+};
+data.jsonText = JSON.stringify(withSrc);
+result = processor.process(data);
+is(typeof result.icons[0].src, "string", expected);
+
+
+expected = `Expect only icons with a src prop to be kept.`;
+withSrc = {
+  icons: [{
+    src: "pass",
+  }, {
+    src: "pass",
+  }, {}, {
+    foo: "foo",
+  }],
+};
+data.jsonText = JSON.stringify(withSrc);
+result = processor.process(data);
+is(result.icons.length, 2, expected);
+
+var expectedURL = new URL("pass", manifestURL);
+for (var icon of result.icons) {
+  expected = `Expect src prop to be ${expectedURL.toString()}`;
+  is(icon.src.toString(), expectedURL.toString(), expected);
+}
+
+
+// Resolve URLs relative to manfiest
+var URLs = ["path", "/path", "../../path"];
+
+URLs.forEach((url) => {
+  expected = `Resolve icon src URLs relative to manifest.`;
+  data.jsonText = JSON.stringify({
+    icons: [{
+      src: url,
+    }],
+  });
+  var absURL = new URL(url, manifestURL).toString();
+  result = processor.process(data);
+  is(result.icons[0].src.toString(), absURL, expected);
+});
+
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ImageObjectProcessor_type.html b/dom/manifest/test/test_ImageObjectProcessor_type.html
new file mode 100644
index 0000000000..29627c5e46
--- /dev/null
+++ b/dom/manifest/test/test_ImageObjectProcessor_type.html
@@ -0,0 +1,57 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * Image object's type property
+ * https://w3c.github.io/manifest/#type-member
+ **/
+
+"use strict";
+var testIcon = {
+  icons: [{
+    src: "test",
+    type: undefined,
+  }],
+};
+
+var invalidMimeTypes = [
+  "application / text",
+  "test;test",
+  ";test?test",
+  "application\\text",
+  "image/jpeg, image/gif",
+];
+invalidMimeTypes.forEach((invalidMime) => {
+  var expected = `Expect invalid mime to be treated like undefined.`;
+  testIcon.icons[0].type = invalidMime;
+  data.jsonText = JSON.stringify(testIcon);
+  var result = processor.process(data);
+  is(result.icons[0].type, undefined, expected);
+});
+
+var validTypes = [
+  "image/jpeg",
+  "IMAGE/jPeG",
+  `${whiteSpace}image/jpeg${whiteSpace}`,
+  "image/JPEG; whatever=something",
+  "image/JPEG;whatever",
+];
+
+validTypes.forEach((validMime) => {
+  var expected = `Expect valid mime to be parsed to : image/jpeg.`;
+  testIcon.icons[0].type = validMime;
+  data.jsonText = JSON.stringify(testIcon);
+  var result = processor.process(data);
+  is(result.icons[0].type, "image/jpeg", expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_JSON.html b/dom/manifest/test/test_ManifestProcessor_JSON.html
new file mode 100644
index 0000000000..b072355f20
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_JSON.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * JSON parsing/processing tests
+ * https://w3c.github.io/manifest/#processing
+ **/
+"use strict";
+var invalidJson = ["", ` \t \n ${whiteSpace} `, "{", "{[[}"];
+invalidJson.forEach((testString) => {
+  var expected = `Expect to recover from invalid JSON: ${testString}`;
+  data.jsonText = testString;
+  data.checkConformance = true;
+  var result = processor.process(data);
+  SimpleTest.is(result.start_url, docURL.href, expected);
+  SimpleTest.ok(
+    [...result.moz_validation].find(x => x.error && x.type === "json"),
+    "A JSON error message is included");
+});
+
+var validButUnhelpful = ["1", 1, "[{}]"];
+validButUnhelpful.forEach((testString) => {
+  var expected = `Expect to recover from valid JSON: ${testString}`;
+  data.jsonText = testString;
+  var result = processor.process(data);
+  SimpleTest.is(result.start_url, docURL.href, expected);
+});
+
+// Bug 1534756 - Allow for null manifests
+var input = {
+  jsonText: "null",
+  manifestURL,
+  docURL,
+};
+var result = processor.process(input);
+SimpleTest.is(result, null, "Expected null when the input is null");
+
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_background_color.html b/dom/manifest/test/test_ManifestProcessor_background_color.html
new file mode 100644
index 0000000000..38073b8e4f
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_background_color.html
@@ -0,0 +1,22 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1195018
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1195018</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * background_color member
+ * https://w3c.github.io/manifest/#background_color-member
+ **/
+"use strict";
+
+testValidColors("background_color");
+testInvalidColors("background_color");
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_dir.html b/dom/manifest/test/test_ManifestProcessor_dir.html
new file mode 100644
index 0000000000..b5dc84a9e4
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_dir.html
@@ -0,0 +1,57 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1258899
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1258899</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * dir member
+ * https://w3c.github.io/manifest/#dir-member
+ **/
+"use strict";
+// Type checks
+typeTests.forEach((type) => {
+  var expected = `Expect non - string dir to default to "auto".`;
+  data.jsonText = JSON.stringify({
+    dir: type,
+  });
+  var result = processor.process(data);
+  is(result.dir, "auto", expected);
+});
+
+/* Test valid values*/
+var validDirs = ["ltr", "rtl", "auto"];
+validDirs.forEach((dir) => {
+  var expected = `Expect dir value to be ${dir}.`;
+  data.jsonText = JSON.stringify({dir});
+  var result = processor.process(data);
+  is(result.dir, dir, expected);
+});
+
+// trim tests
+validDirs.forEach((dir) => {
+  var expected = `Expect trimmed dir to be returned.`;
+  var expandeddir =  seperators + lineTerminators + dir + lineTerminators + seperators;
+  data.jsonText = JSON.stringify({
+    dir: expandeddir,
+  });
+  var result = processor.process(data);
+  is(result.dir, dir, expected);
+});
+
+// Unknown/Invalid directions
+var invalidDirs = ["LTR", "RtL", `fooo${whiteSpace}rtl`, "", "bar baz, some value", "ltr rtl auto", "AuTo"];
+invalidDirs.forEach((dir) => {
+  var expected = `Expect default dir "auto" to be returned: '${dir}'`;
+  data.jsonText = JSON.stringify({dir});
+  var result = processor.process(data);
+  is(result.dir, "auto", expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_display.html b/dom/manifest/test/test_ManifestProcessor_display.html
new file mode 100644
index 0000000000..f5ea5fbc4f
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_display.html
@@ -0,0 +1,78 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * display member
+ * https://w3c.github.io/manifest/#display-member
+ **/
+"use strict";
+// Type checks
+typeTests.forEach((type) => {
+  var expected = `Expect non - string display to default to "browser".`;
+  data.jsonText = JSON.stringify({
+    display: type,
+  });
+  var result = processor.process(data);
+  is(result.display, "browser", expected);
+});
+
+/* Test valid modes - case insensitive*/
+var validModes = [
+  "fullscreen",
+  "standalone",
+  "minimal-ui",
+  "browser",
+  "FullScreen",
+  "standAlone",
+  "minimal-UI",
+  "BROWSER",
+];
+validModes.forEach((mode) => {
+  var expected = `Expect display mode to be ${mode.toLowerCase()}.`;
+  data.jsonText = JSON.stringify({
+    display: mode,
+  });
+  var result = processor.process(data);
+  is(result.display, mode.toLowerCase(), expected);
+});
+
+// trim tests
+validModes.forEach((display) => {
+  var expected = `Expect trimmed display mode to be returned.`;
+  var expandedDisplay =  seperators + lineTerminators + display + lineTerminators + seperators;
+  data.jsonText = JSON.stringify({
+    display: expandedDisplay,
+  });
+  var result = processor.process(data);
+  is(result.display, display.toLowerCase(), expected);
+});
+
+// Unknown modes
+var invalidModes = [
+  "foo",
+  `fooo${whiteSpace}`,
+  "",
+  "fullscreen,standalone",
+  "standalone fullscreen",
+  "FULLSCreENS",
+];
+
+invalidModes.forEach((invalidMode) => {
+  var expected = `Expect default display mode "browser" to be returned: '${invalidMode}'`;
+  data.jsonText = JSON.stringify({
+    display: invalidMode,
+  });
+  var result = processor.process(data);
+  is(result.display, "browser", expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_icons.html b/dom/manifest/test/test_ManifestProcessor_icons.html
new file mode 100644
index 0000000000..578f49f5dc
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_icons.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * Manifest icons member
+ * https://w3c.github.io/manifest/#icons-member
+ **/
+
+"use strict";
+
+typeTests.forEach((type) => {
+  var expected = `Expect non-array icons to be empty array: ${typeof type}.`;
+  data.jsonText = JSON.stringify({
+    icons: type,
+  });
+  var result = processor.process(data);
+  SpecialPowers.unwrap(result.icons);
+  is(result.icons.length, 0, expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_id.html b/dom/manifest/test/test_ManifestProcessor_id.html
new file mode 100644
index 0000000000..336d1d3a77
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_id.html
@@ -0,0 +1,123 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1731940
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1731940 - implement id member</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+  /**
+   * Manifest id member
+   * https://w3c.github.io/manifest/#id-member
+   **/
+  for (const type of typeTests) {
+    data.jsonText = JSON.stringify({
+      id: type,
+    });
+    const result = processor.process(data);
+    is(
+      result.id.toString(),
+      result.start_url.toString(),
+      `Expect non-string id to fall back to start_url: ${typeof type}.`
+    );
+  }
+
+  // Invalid URLs
+  const invalidURLs = [
+    "https://foo:65536",
+    "https://foo\u0000/",
+    "//invalid:65555",
+    "file:///passwords",
+    "about:blank",
+    "data:text/html,<html><script>alert('lol')<\/script></html>",
+  ];
+
+  for (const url of invalidURLs) {
+    data.jsonText = JSON.stringify({
+      id: url,
+    });
+    const result = processor.process(data);
+    is(
+      result.id.toString(),
+      result.start_url.toString(),
+      "Expect invalid id URL to fall back to start_url."
+    );
+  }
+
+  // Not same origin
+  data.jsonText = JSON.stringify({
+    id: "http://not-same-origin",
+  });
+  var result = processor.process(data);
+  is(
+    result.id.toString(),
+    result.start_url,
+    "Expect different origin id to fall back to start_url."
+  );
+
+  // Empty string test
+  data.jsonText = JSON.stringify({
+    id: "",
+  });
+  result = processor.process(data);
+  is(
+    result.id.toString(),
+    result.start_url.toString(),
+    `Expect empty string for id to use start_url.`
+  );
+
+  // Resolve URLs relative to the start_url's origin
+  const URLs = [
+    "path",
+    "/path",
+    "../../path",
+    "./path",
+    `${whiteSpace}path${whiteSpace}`,
+    `${whiteSpace}/path`,
+    `${whiteSpace}../../path`,
+    `${whiteSpace}./path`,
+  ];
+
+  for (const url of URLs) {
+    data.jsonText = JSON.stringify({
+      id: url,
+      start_url: "/path/some.html",
+    });
+    result = processor.process(data);
+    const baseOrigin = new URL(result.start_url.toString()).origin;
+    const expectedUrl = new URL(url, baseOrigin).toString();
+    is(
+      result.id.toString(),
+      expectedUrl,
+      "Expected id to be resolved relative to start_url's origin."
+    );
+  }
+
+  // Handles unicode encoded URLs
+  const specialCases = [
+    ["😀", "%F0%9F%98%80"],
+    [
+      "this/is/ok?query_is_ok=😀#keep_hash",
+      "this/is/ok?query_is_ok=%F0%9F%98%80#keep_hash",
+    ],
+  ];
+  for (const [id, expected] of specialCases) {
+    data.jsonText = JSON.stringify({
+      id,
+      start_url: "/my-app/",
+    });
+    result = processor.process(data);
+    const baseOrigin = new URL(result.start_url.toString()).origin;
+    const expectedUrl = new URL(expected, baseOrigin).toString();
+    is(
+      result.id.toString(),
+      expectedUrl,
+      `Expect id to be encoded/decoded per URL spec.`
+    );
+  }
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_lang.html b/dom/manifest/test/test_ManifestProcessor_lang.html
new file mode 100644
index 0000000000..568950c2ba
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_lang.html
@@ -0,0 +1,139 @@
+<!DOCTYPE HTML>
+<meta charset="utf-8">
+<!--
+Bug 1143879 - Implement lang member of Web manifest
+https://bugzilla.mozilla.org/show_bug.cgi?id=1143879
+-->
+<meta charset="utf-8">
+<title>Test for Bug 1143879 - Implement lang member of Web manifest</title>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+<script src="common.js"></script>
+<script>
+/**
+ * lang member
+ * https://w3c.github.io/manifest/#lang-member
+ **/
+/* globals is, typeTests, data, processor, seperators, lineTerminators, todo_is*/
+"use strict";
+// Type checks: checks that only strings are accepted.
+
+for (const type of typeTests) {
+  const expected = `Expect non-string to be undefined.`;
+  data.jsonText = JSON.stringify({
+    lang: type,
+  });
+  const result = processor.process(data);
+  is(result.lang, undefined, expected);
+}
+
+// Test valid language tags - derived from IANA and BCP-47 spec
+// and our Intl.js implementation.
+var validTags = [
+  "aa", "ab", "ae", "af", "ak", "am", "an", "ar", "as", "av", "ay", "az",
+  "ba", "be", "bg", "bi", "bm", "bn", "bo", "br", "bs", "ca", "ce",
+  "ch", "co", "cr", "cs", "cu", "cv", "cy", "da", "de", "dv", "dz", "ee",
+  "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fj", "fo", "fr",
+  "fy", "ga", "gd", "gl", "gn", "gu", "gv", "ha", "he", "hi", "ho", "hr",
+  "ht", "hu", "hy", "hz", "ia", "id", "ie", "ig", "ik", "io",
+  "is", "it", "iu", "ja", "jv", "ka", "kg", "ki", "kj",
+  "kk", "kl", "km", "kn", "ko", "kr", "ks", "ku", "kv", "kw", "ky", "la",
+  "lb", "lg", "li", "ln", "lo", "lt", "lu", "lv", "mg", "mh", "mi", "mk",
+  "ml", "mn", "mr", "ms", "mt", "my", "na", "nb", "nd", "ne", "ng",
+  "nl", "nn", "no", "nr", "nv", "ny", "oc", "oj", "om", "or", "os", "pa",
+  "pi", "pl", "ps", "pt", "qu", "rm", "rn", "ro", "ru", "rw", "sa", "sc",
+  "sd", "se", "sg", "si", "sk", "sl", "sm", "sn", "so", "sq", "sr",
+  "ss", "st", "su", "sv", "sw", "ta", "te", "tg", "th", "ti", "tk",
+  "tn", "to", "tr", "ts", "tt", "ty", "ug", "uk", "ur", "uz", "ve",
+  "vi", "vo", "wa", "wo", "xh", "yi", "yo", "za", "zh", "zu", "en-US",
+  "jp-JS", "pt-PT", "pt-BR", "de-CH", "de-DE-1901", "es-419", "sl-IT-nedis",
+  "en-US-boont", "mn-Cyrl-MN", "sr-Cyrl", "sr-Latn",
+  "zh-TW", "en-GB-boont-posix-r-extended-sequence-x-private",
+  "yue-HK", "de-CH-x-phonebk", "az-Arab-x-aze-derbend",
+  "qaa-Qaaa-QM-x-southern",
+];
+
+
+for (var tag of validTags) {
+  const expected = `Expect lang to be "${tag}"`;
+  data.jsonText = JSON.stringify({
+    lang: tag,
+  });
+  const result = processor.process(data);
+  is(result.lang, tag, expected);
+}
+
+// Canonical form conversion... old names become new names.
+const granfatheredTags = [
+  ["bh", "bho"],
+  ["in", "id"],
+  ["iw", "he"],
+  ["ji", "yi"],
+  ["jw", "jv"],
+  ["mo", "ro"],
+  ["sh", "sr-Latn"],
+  ["tl", "fil"],
+  ["tw", "ak"],
+  ["nan-Hans-MM-variant2-variant1-t-zh-latn-u-ca-chinese-x-private",
+   "nan-Hans-MM-variant1-variant2-t-zh-latn-u-ca-chinese-x-private"],
+  ["cmn-Hans-CN", "zh-Hans-CN"],
+];
+
+for (const [oldTag, newTag] of granfatheredTags) {
+  const expected = `Expect lang to be "${newTag}"`;
+  data.jsonText = JSON.stringify({
+    lang: oldTag,
+  });
+  const result = processor.process(data);
+  is(result.lang, newTag, expected);
+}
+
+// trim tests - check that language tags get trimmed properly.
+for (tag of validTags) {
+  const expected = `Expect trimmed tag to be returned.`;
+  let expandedtag = seperators + lineTerminators + tag;
+  expandedtag += lineTerminators + seperators;
+  data.jsonText = JSON.stringify({
+    lang: expandedtag,
+  });
+  const result = processor.process(data);
+  is(result.lang, tag, expected);
+}
+
+// Invalid language tags, derived from BCP-47 and made up.
+var invalidTags = [
+"de-419-DE", " a-DE ", "ar-a-aaa-b-bbb-a-ccc", "sdafsdfaadsfdsf", "i",
+"i-phone", "en US", "EN-*-US-JP", "JA-INVALID-TAG", "123123123",
+];
+
+
+for (var item of invalidTags) {
+  const expected = `Expect invalid tag (${item}) to be treated as undefined.`;
+  data.jsonText = JSON.stringify({
+    lang: item,
+  });
+  const result = processor.process(data);
+  is(result.lang, undefined, expected);
+}
+
+// Canonical form conversion tests. We convert the following tags, which are in
+// canonical form, to upper case and expect the processor to return them
+// in canonical form.
+var canonicalTags = [
+  "jp-JS", "pt-PT", "pt-BR", "de-CH", "de-DE-1901", "es-419", "sl-IT-nedis",
+  "en-US-boont", "mn-Cyrl-MN", "sr-Cyrl", "sr-Latn",
+  "hy-Latn-IT", "zh-TW", "en-GB-boont-r-extended-sequence-x-private",
+  "yue-HK", "de-CH-x-phonebk", "az-Arab-x-aze-derbend",
+  "qaa-Qaaa-QM-x-southern",
+];
+
+for (tag of canonicalTags) {
+  var uppedTag = tag.toUpperCase();
+  const expected = `Expect tag (${uppedTag}) to be in canonical form (${tag}).`;
+  data.jsonText = JSON.stringify({
+    lang: uppedTag,
+  });
+  const result = processor.process(data);
+  is(result.lang, tag, expected);
+}
+</script>
diff --git a/dom/manifest/test/test_ManifestProcessor_name_and_short_name.html b/dom/manifest/test/test_ManifestProcessor_name_and_short_name.html
new file mode 100644
index 0000000000..e843b583e4
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_name_and_short_name.html
@@ -0,0 +1,79 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * name and short_name members
+ * https://w3c.github.io/manifest/#name-member
+ * https://w3c.github.io/manifest/#short_name-member
+ **/
+
+"use strict";
+
+var trimNamesTests = [
+  `${seperators}pass${seperators}`,
+  `${lineTerminators}pass${lineTerminators}`,
+  `${whiteSpace}pass${whiteSpace}`,
+  // BOM
+  `\uFEFFpass\uFEFF`,
+];
+var props = ["name", "short_name"];
+
+props.forEach((prop) => {
+  trimNamesTests.forEach((trimmableString) => {
+    var assetion = `Expecting ${prop} to be trimmed.`;
+    var obj = {};
+    obj[prop] = trimmableString;
+    data.jsonText = JSON.stringify(obj);
+    var result = processor.process(data);
+    is(result[prop], "pass", assetion);
+  });
+});
+
+/*
+ * If the object is not a string, it becomes undefined
+ */
+props.forEach((prop) => {
+  typeTests.forEach((type) => {
+    var expected = `Expect non - string ${prop} to be undefined: ${typeof type}`;
+    var obj = {};
+    obj[prop] = type;
+    data.jsonText = JSON.stringify(obj);
+    var result = processor.process(data);
+    SimpleTest.ok(result[prop] === undefined, expected);
+  });
+});
+
+/**
+ * acceptable names - including long names
+ */
+var acceptableNames = [
+  "pass",
+  `pass pass pass pass pass pass pass pass pass pass pass pass pass pass
+   pass pass pass pass pass pass pass pass pass pass pass pass pass pass
+   pass pass pass pass pass pass pass pass pass pass pass pass pass pass
+   pass pass pass pass pass pass pass pass pass pass pass pass`,
+  "これは許容できる名前です",
+  "ນີ້ແມ່ນຊື່ທີ່ຍອມຮັບໄດ້",
+];
+
+props.forEach((prop) => {
+  acceptableNames.forEach((name) => {
+    var expected = `Expecting name to be acceptable : ${name}`;
+    var obj = {};
+    obj[prop] = name;
+    data.jsonText = JSON.stringify(obj);
+    var result = processor.process(data);
+    is(result[prop], name, expected);
+  });
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_orientation.html b/dom/manifest/test/test_ManifestProcessor_orientation.html
new file mode 100644
index 0000000000..9333eecbe3
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_orientation.html
@@ -0,0 +1,86 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * orientation member
+ * https://w3c.github.io/manifest/#orientation-member
+ **/
+"use strict";
+
+typeTests.forEach((type) => {
+  var expected = `Expect non-string orientation to be empty string : ${typeof type}.`;
+  data.jsonText = JSON.stringify({
+    orientation: type,
+  });
+  var result = processor.process(data);
+  is(result.orientation, undefined, expected);
+});
+
+var validOrientations = [
+  "any",
+  "natural",
+  "landscape",
+  "portrait",
+  "portrait-primary",
+  "portrait-secondary",
+  "landscape-primary",
+  "landscape-secondary",
+  "aNy",
+  "NaTuRal",
+  "LANDsCAPE",
+  "PORTRAIT",
+  "portrait-PRIMARY",
+  "portrait-SECONDARY",
+  "LANDSCAPE-primary",
+  "LANDSCAPE-secondary",
+];
+
+validOrientations.forEach((orientation) => {
+  var expected = `Expect orientation to be returned: ${orientation}.`;
+  data.jsonText = JSON.stringify({ orientation });
+  var result = processor.process(data);
+  is(result.orientation, orientation.toLowerCase(), expected);
+});
+
+var invalidOrientations = [
+  "all",
+  "ANYMany",
+  "NaTuRalle",
+  "portrait-primary portrait-secondary",
+  "portrait-primary,portrait-secondary",
+  "any-natural",
+  "portrait-landscape",
+  "primary-portrait",
+  "secondary-portrait",
+  "landscape-landscape",
+  "secondary-primary",
+];
+
+invalidOrientations.forEach((orientation) => {
+  var expected = `Expect orientation to be empty string: ${orientation}.`;
+  data.jsonText = JSON.stringify({ orientation });
+  var result = processor.process(data);
+  is(result.orientation, undefined, expected);
+});
+
+// Trim tests
+validOrientations.forEach((orientation) => {
+  var expected = `Expect trimmed orientation to be returned.`;
+  var expandedOrientation = `${seperators}${lineTerminators}${orientation}${lineTerminators}${seperators}`;
+  data.jsonText = JSON.stringify({
+    orientation: expandedOrientation,
+  });
+  var result = processor.process(data);
+  is(result.orientation, orientation.toLowerCase(), expected);
+});
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_scope.html b/dom/manifest/test/test_ManifestProcessor_scope.html
new file mode 100644
index 0000000000..590d76a251
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_scope.html
@@ -0,0 +1,113 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+
+/**
+ * Manifest scope
+ * https://w3c.github.io/manifest/#scope-member
+ **/
+"use strict";
+
+var expected = "Expect non-string scope to be the default";
+typeTests.forEach((type) => {
+  data.jsonText = JSON.stringify({
+    scope: type,
+  });
+  var result = processor.process(data);
+  is(result.scope, new URL(".", docURL).href, expected);
+});
+
+expected = "Expect different origin to be the default";
+data.jsonText = JSON.stringify({
+  scope: "http://not-same-origin",
+});
+var result = processor.process(data);
+is(result.scope, new URL(".", docURL).href, expected);
+
+expected = "Expect the empty string to be the default";
+data.jsonText = JSON.stringify({
+  scope: "",
+});
+result = processor.process(data);
+is(result.scope, new URL(".", docURL).href, expected);
+
+expected = "Resolve URLs relative to manifest.";
+var URLs = ["path", "/path", "../../path"];
+URLs.forEach((url) => {
+  data.jsonText = JSON.stringify({
+    scope: url,
+    start_url: "/path",
+  });
+  var absURL = new URL(url, manifestURL).toString();
+  result = processor.process(data);
+  is(result.scope, absURL, expected);
+});
+
+expected = "If start URL is not in scope, return the default.";
+data.jsonText = JSON.stringify({
+  scope: "foo",
+  start_url: "bar",
+});
+result = processor.process(data);
+let expected_start = new URL("bar", docURL);
+is(result.scope, new URL(document.location.origin).href, expected);
+
+expected = "If start URL is in scope, use the scope.";
+data.jsonText = JSON.stringify({
+  start_url: "foobar",
+  scope: "foo",
+});
+result = processor.process(data);
+is(result.scope.toString(), new URL("foo", manifestURL).toString(), expected);
+
+expected = "Expect start_url to be " + new URL("foobar", manifestURL).toString();
+is(result.start_url.toString(), new URL("foobar", manifestURL).toString(), expected);
+
+expected = "If start URL is in scope, use the scope.";
+data.jsonText = JSON.stringify({
+  start_url: "/foo/",
+  scope: "/foo/",
+});
+result = processor.process(data);
+is(result.scope.toString(), new URL("/foo/", manifestURL).toString(), expected);
+
+expected = "If start URL is in scope, use the scope.";
+data.jsonText = JSON.stringify({
+  start_url: ".././foo/",
+  scope: "../foo/",
+});
+result = processor.process(data);
+is(result.scope.toString(), new URL("/foo/", manifestURL).toString(), expected);
+
+expected = "scope member has the URL's query removed.";
+data.jsonText = JSON.stringify({
+  scope: "./test/?a=b&a=b&b=c&c=d&e",
+});
+result = processor.process(data);
+is(new URL(result.scope).search, "", expected);
+
+expected = "scope member has the URL's fragment removed.";
+data.jsonText = JSON.stringify({
+  scope: "./test/#fragment"
+});
+result = processor.process(data);
+is(new URL(result.scope).hash, "", expected);
+
+expected = "scope member has the URL's query and fragment removed.";
+data.jsonText = JSON.stringify({
+  scope: "./test/?a=b&a=b&b=c&c=d&e#fragment"
+});
+result = processor.process(data);
+is(new URL(result.scope).search, "", expected);
+is(new URL(result.scope).hash, "", expected);
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_start_url.html b/dom/manifest/test/test_ManifestProcessor_start_url.html
new file mode 100644
index 0000000000..1d172df555
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_start_url.html
@@ -0,0 +1,83 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1079453
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1079453</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * Manifest start_url
+ * https://w3c.github.io/manifest/#start_url-member
+ **/
+"use strict";
+typeTests.forEach((type) => {
+  var expected = `Expect non - string start_url to be doc's url: ${typeof type}.`;
+  data.jsonText = JSON.stringify({
+    start_url: type,
+  });
+  var result = processor.process(data);
+  is(result.start_url.toString(), docURL.toString(), expected);
+});
+
+// Not same origin
+var expected = `Expect different origin URLs to become document's URL.`;
+data.jsonText = JSON.stringify({
+  start_url: "http://not-same-origin",
+});
+var result = processor.process(data);
+is(result.start_url.toString(), docURL.toString(), expected);
+
+// Empty string test
+expected = `Expect empty string for start_url to become document's URL.`;
+data.jsonText = JSON.stringify({
+  start_url: "",
+});
+result = processor.process(data);
+is(result.start_url.toString(), docURL.toString(), expected);
+
+// Resolve URLs relative to manifest
+var URLs = [
+  "path",
+  "/path",
+  "../../path",
+  `${whiteSpace}path${whiteSpace}`,
+  `${whiteSpace}/path`,
+  `${whiteSpace}../../path`,
+];
+
+URLs.forEach((url) => {
+  expected = `Resolve URLs relative to manifest.`;
+  data.jsonText = JSON.stringify({
+    start_url: url,
+  });
+  var absURL = new URL(url, manifestURL).toString();
+  result = processor.process(data);
+  is(result.start_url.toString(), absURL, expected);
+});
+
+// It retains the fragment
+var startURL = "./path?query=123#fragment";
+data.jsonText = JSON.stringify({
+  start_url: startURL,
+});
+var absURL = new URL(startURL, manifestURL).href;
+result = processor.process(data);
+is(result.start_url.toString(), absURL, "Retains fragment");
+
+// It retains the fragment on the document's location too.
+window.location = "#here";
+data.jsonText = JSON.stringify({});
+result = processor.process(data);
+is(
+  window.location.href,
+  result.start_url.toString(),
+  `Retains the fragment of document's location`
+);
+</script>
+  </head>
+</html>
diff --git a/dom/manifest/test/test_ManifestProcessor_theme_color.html b/dom/manifest/test/test_ManifestProcessor_theme_color.html
new file mode 100644
index 0000000000..c73832748d
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_theme_color.html
@@ -0,0 +1,22 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1195018
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1195018</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+/**
+ * theme_color member
+ * https://w3c.github.io/manifest/#theme_color-member
+ **/
+"use strict";
+
+testValidColors("theme_color");
+testInvalidColors("theme_color");
+  </script>
+</head>
diff --git a/dom/manifest/test/test_ManifestProcessor_warnings.html b/dom/manifest/test/test_ManifestProcessor_warnings.html
new file mode 100644
index 0000000000..f2092c1dcf
--- /dev/null
+++ b/dom/manifest/test/test_ManifestProcessor_warnings.html
@@ -0,0 +1,149 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1086997
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1086997</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="common.js"></script>
+  <script>
+"use strict";
+const options = {...data, checkConformance: true } ;
+[
+  {
+    func: () => options.jsonText = JSON.stringify(1),
+    warn: "Manifest should be an object.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify("a string"),
+    warn: "Manifest should be an object.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      scope: "https://www.mozilla.org",
+    }),
+    warn: "The scope URL must be same origin as document.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      scope: "foo",
+      start_url: "bar",
+    }),
+    warn: "The start URL is outside the scope, so the scope is invalid.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      start_url: "https://www.mozilla.org",
+    }),
+    warn: "The start URL must be same origin as document.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      start_url: 42,
+    }),
+    warn: "Expected the manifest\u2019s start_url member to be a string.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      theme_color: "42",
+    }),
+    warn: "theme_color: 42 is not a valid CSS color.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      background_color: "42",
+    }),
+    warn: "background_color: 42 is not a valid CSS color.",
+  },
+  {
+    func: () => options.jsonText = JSON.stringify({
+      icons: [
+        { "src": "http://example.com", "sizes": "48x48"},
+        { "src": "http://:Invalid", "sizes": "48x48"},
+      ],
+    }),
+    warn: "icons item at index 1 is invalid. The src member is an invalid URL http://:Invalid",
+  },
+  // testing dom.properties: ManifestImageUnusable
+  {
+    func() {
+      return (options.jsonText = JSON.stringify({
+        icons: [
+          { src: "http://example.com", purpose: "any" }, // valid
+          { src: "http://example.com", purpose: "banana" }, // generates error
+        ],
+      }));
+    },
+    get warn() {
+      // Returns 2 warnings... array here is just to keep them organized
+      return [
+        "icons item at index 1 includes unsupported purpose(s): banana.",
+        "icons item at index 1 lacks a usable purpose. It will be ignored.",
+      ].join(" ");
+    },
+  },
+  // testing dom.properties: ManifestImageUnsupportedPurposes
+  {
+    func() {
+      return (options.jsonText = JSON.stringify({
+        icons: [
+          { src: "http://example.com", purpose: "any" }, // valid
+          { src: "http://example.com", purpose: "any foo bar baz bar bar baz" }, // generates error
+        ],
+      }));
+    },
+    warn: "icons item at index 1 includes unsupported purpose(s): foo bar baz.",
+  },
+  // testing dom.properties: ManifestImageRepeatedPurposes
+  {
+    func() {
+      return (options.jsonText = JSON.stringify({
+        icons: [
+          { src: "http://example.com", purpose: "any" }, // valid
+          {
+            src: "http://example.com",
+            purpose: "any maskable any maskable maskable", // generates error
+          },
+        ],
+      }));
+    },
+    warn: "icons item at index 1 includes repeated purpose(s): any maskable.",
+  },
+  // testing dom.properties: ManifestIdIsInvalid
+  {
+    func() {
+      return (options.jsonText = JSON.stringify({
+        id: "http://test:65536/foo",
+      }));
+    },
+    warn: "The id member did not resolve to a valid URL.",
+  },
+  // testing dom.properties ManifestIdNotSameOrigin
+  {
+    func() {
+      return (options.jsonText = JSON.stringify({
+        id: "https://other.com",
+        start_url: "/this/place"
+      }));
+    },
+    warn: "The id member must have the same origin as the start_url member.",
+  }
+].forEach((test, index) => {
+  test.func();
+  const result = processor.process(options);
+  let messages = [];
+  // Poking directly at "warn" triggers xray security wrapper.
+  for (const validationError of result.moz_validation) {
+    const { warn } = validationError;
+    messages.push(warn);
+  }
+  is(messages.join(" "), test.warn, "Check warning.");
+    options.manifestURL = manifestURL;
+  options.docURL = docURL;
+});
+
+  </script>
+</head>
diff --git a/dom/manifest/test/test_link_relList_supports_manifest.html b/dom/manifest/test/test_link_relList_supports_manifest.html
new file mode 100644
index 0000000000..af678ddb5f
--- /dev/null
+++ b/dom/manifest/test/test_link_relList_supports_manifest.html
@@ -0,0 +1,47 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1596040
+-->
+
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1596040 - Link relList support returns false for manifest</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css">
+  <script>
+  "use strict";
+  SimpleTest.waitForExplicitFinish();
+
+  async function run() {
+    const prefSetting = [
+      { manifest: true, preload: true },
+      { manifest: true, preload: false },
+      { manifest: false, preload: true },
+      { manifest: false, preload: false },
+    ];
+    for (const { manifest, preload } of prefSetting) {
+      await SpecialPowers.pushPrefEnv({
+        set: [
+          ["dom.manifest.enabled", manifest],
+          ["network.preload", preload],
+        ],
+      });
+      const { relList } = document.createElement("link");
+      is(
+        relList.supports("manifest"),
+        manifest,
+        `Expected manifest to be ${manifest}`
+      );
+      is(
+        relList.supports("preload"),
+        preload,
+        `Expected preload to be ${preload}`
+      );
+    }
+  }
+  run()
+    .catch(console.error)
+    .finally(() => SimpleTest.finish());
+  </script>
+</head>