Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 202 insertions, 0 deletions

diff --git a/chrome/test/unit/test_no_remote_registration.js b/chrome/test/unit/test_no_remote_registration.js
new file mode 100644
index 0000000000..46303ef312
--- /dev/null
+++ b/chrome/test/unit/test_no_remote_registration.js
@@ -0,0 +1,202 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 sts=2 tw=78 expandtab :
+ * 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/. */
+
+var manifests = [do_get_file("data/test_no_remote_registration.manifest")];
+registerManifests(manifests);
+
+function ProtocolHandler(aScheme) {
+  this.scheme = aScheme;
+}
+
+ProtocolHandler.prototype = {
+  allowPort: () => false,
+  newChannel() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsIProtocolHandler"]),
+};
+
+var testProtocols = [
+  // It doesn't matter if it has this flag - the only flag we accept is
+  // URI_IS_LOCAL_RESOURCE.
+  {
+    scheme: "moz-protocol-ui-resource",
+    flags: Ci.nsIProtocolHandler.URI_IS_UI_RESOURCE,
+    shouldRegister: false,
+  },
+  // It doesn't matter if it has this flag - the only flag we accept is
+  // URI_IS_LOCAL_RESOURCE.
+  {
+    scheme: "moz-protocol-local-file",
+    flags: Ci.nsIProtocolHandler.URI_IS_LOCAL_FILE,
+    shouldRegister: false,
+  },
+  // This clearly is non-local
+  {
+    scheme: "moz-protocol-loadable-by-anyone",
+    flags: Ci.nsIProtocolHandler.URI_LOADABLE_BY_ANYONE,
+    shouldRegister: false,
+  },
+  // This should always be last (unless we add more flags that are OK)
+  {
+    scheme: "moz-protocol-local-resource",
+    flags: Ci.nsIProtocolHandler.URI_IS_LOCAL_RESOURCE,
+    shouldRegister: true,
+  },
+];
+function run_test() {
+  const { newAppInfo } = ChromeUtils.importESModule(
+    "resource://testing-common/AppInfo.sys.mjs"
+  );
+  let XULAppInfo = newAppInfo({
+    name: "XPCShell",
+    ID: "{39885e5f-f6b4-4e2a-87e5-6259ecf79011}",
+    version: "5",
+    platformVersion: "1.9",
+  });
+
+  const uuidGenerator = Services.uuid;
+
+  let XULAppInfoFactory = {
+    // These two are used when we register all our factories (and unregister)
+    CID: uuidGenerator.generateUUID(),
+    scheme: "XULAppInfo",
+    contractID: "@mozilla.org/xre/app-info;1",
+    createInstance(iid) {
+      return XULAppInfo.QueryInterface(iid);
+    },
+  };
+
+  for (let protocol of testProtocols) {
+    Services.io.registerProtocolHandler(
+      protocol.scheme,
+      new ProtocolHandler(protocol.scheme),
+      protocol.flags,
+      -1
+    );
+  }
+
+  let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+
+  // Register the XULAppInfoFactory
+  // Make sure the class ID has not already been registered
+  let old_factory = { CID: "", factory: null };
+  if (!registrar.isCIDRegistered(XULAppInfoFactory.CID)) {
+    // Check to see if a contract was already registered and
+    // register it if it is not. Otherwise, store the previous one
+    // to be restored later and register the new one.
+    if (registrar.isContractIDRegistered(XULAppInfoFactory.contractID)) {
+      dump(
+        XULAppInfoFactory.scheme +
+          " is already registered. Storing currently registered object for restoration later."
+      );
+      old_factory.CID = registrar.contractIDToCID(XULAppInfoFactory.contractID);
+      old_factory.factory = Components.manager.getClassObject(
+        Cc[XULAppInfoFactory.contractID],
+        Ci.nsIFactory
+      );
+    } else {
+      dump(
+        XULAppInfoFactory.scheme + " has never been registered. Registering..."
+      );
+    }
+
+    registrar.registerFactory(
+      XULAppInfoFactory.CID,
+      "test-" + XULAppInfoFactory.scheme,
+      XULAppInfoFactory.contractID,
+      XULAppInfoFactory
+    );
+  } else {
+    do_throw("CID " + XULAppInfoFactory.CID + " has already been registered!");
+  }
+
+  // Check for new chrome
+  let cr = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(
+    Ci.nsIChromeRegistry
+  );
+  cr.checkForNewChrome();
+
+  // See if our various things were able to register
+  let registrationTypes = ["content", "locale", "skin", "override", "resource"];
+  for (let i = 0; i < testProtocols.length; i++) {
+    let protocol = testProtocols[i];
+    for (let j = 0; j < registrationTypes.length; j++) {
+      let type = registrationTypes[j];
+      dump(
+        "Testing protocol '" + protocol.scheme + "' with type '" + type + "'\n"
+      );
+      let expectedURI = protocol.scheme + "://foo/";
+      let sourceURI = "chrome://" + protocol.scheme + "/" + type + "/";
+      switch (type) {
+        case "content":
+          expectedURI += protocol.scheme + ".xul";
+          break;
+        case "locale":
+          expectedURI += protocol.scheme + ".dtd";
+          break;
+        case "skin":
+          expectedURI += protocol.scheme + ".css";
+          break;
+        case "override":
+          sourceURI =
+            "chrome://good-package/content/override-" +
+            protocol.scheme +
+            ".xul";
+          break;
+        case "resource":
+          sourceURI = "resource://" + protocol.scheme + "/";
+          break;
+      }
+      try {
+        sourceURI = Services.io.newURI(sourceURI);
+        let uri;
+        if (type == "resource") {
+          // resources go about a slightly different way than everything else
+          let rph = Services.io
+            .getProtocolHandler("resource")
+            .QueryInterface(Ci.nsIResProtocolHandler);
+          // this throws for packages that are not registered
+          uri = rph.resolveURI(sourceURI);
+        } else {
+          // this throws for packages that are not registered
+          uri = cr.convertChromeURL(sourceURI).spec;
+        }
+
+        if (protocol.shouldRegister) {
+          Assert.equal(expectedURI, uri);
+        } else {
+          // Overrides will not throw, so we'll get to here.  We want to make
+          // sure that the two strings are not the same in this situation.
+          Assert.notEqual(expectedURI, uri);
+        }
+      } catch (e) {
+        if (protocol.shouldRegister) {
+          dump(e + "\n");
+          do_throw(
+            "Should have registered our URI for protocol " + protocol.scheme
+          );
+        }
+      }
+    }
+  }
+
+  // Unregister our protocol handlers so we do not leak
+  for (let protocol of testProtocols) {
+    Services.io.unregisterProtocolHandler(protocol.scheme);
+  }
+
+  // Unregister XULAppInfoFactory
+  registrar.unregisterFactory(XULAppInfoFactory.CID, XULAppInfoFactory);
+  if (old_factory.factory != null) {
+    registrar.registerFactory(
+      old_factory.CID,
+      "",
+      XULAppInfoFactory.contractID,
+      null
+    );
+  }
+}