tor-browser

test_no_remote_registration.js (6452B)

---

/* -*- 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
   );
 }
}