Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- Manifest: chrome/test/unit/xpcshell.toml
/* -*- 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
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(
);
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 =
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
);
}
}