The Tor Browser: chrome/test/unit/test_no_remote_registration.js@97036ab72558 (annotated)

chrome/test/unit/test_no_remote_registration.js@97036ab72558 (annotated)

chrome/test/unit/test_no_remote_registration.js

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */
 let manifests = [
   do_get_file("data/test_no_remote_registration.manifest"),
 ];
 registerManifests(manifests);
 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 let XULAppInfo = {
   vendor: "Mozilla",
   name: "XPCShell",
   ID: "{39885e5f-f6b4-4e2a-87e5-6259ecf79011}",
   version: "5",
   appBuildID: "2007010101",
   platformVersion: "1.9",
   platformBuildID: "2007010101",
   inSafeMode: false,
   logConsoleErrors: true,
   OS: "XPCShell",
   XPCOMABI: "noarch-spidermonkey",
   QueryInterface: XPCOMUtils.generateQI([
     Ci.nsIXULAppInfo,
     Ci.nsIXULRuntime,
   ])
 };
 let XULAppInfoFactory = {
   // These two are used when we register all our factories (and unregister)
   CID: XULAPPINFO_CID,
   scheme: "XULAppInfo",
   contractID: XULAPPINFO_CONTRACTID,
   createInstance: function (outer, iid) {
     if (outer != null)
       throw Cr.NS_ERROR_NO_AGGREGATION;
     return XULAppInfo.QueryInterface(iid);
   }
 };
 function ProtocolHandler(aScheme, aFlags)
 {
   this.scheme = aScheme;
   this.protocolFlags = aFlags;
   this.contractID = "@mozilla.org/network/protocol;1?name=" + aScheme;
 }
 ProtocolHandler.prototype =
 {
   defaultPort: -1,
   allowPort: function() false,
   newURI: function(aSpec, aCharset, aBaseURI)
   {
     let uri = Cc["@mozilla.org/network/standard-url;1"].
               createInstance(Ci.nsIURI);
     uri.spec = aSpec;
     if (!uri.scheme) {
       // We got a partial uri, so let's resolve it with the base one
       uri.spec = aBaseURI.resolve(aSpec);
     }
     return uri;
   },
   newChannel: function() { throw Cr.NS_ERROR_NOT_IMPLEMENTED },
   QueryInterface: XPCOMUtils.generateQI([
     Ci.nsIProtocolHandler
   ])
 };
 let 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,
    CID: Components.ID("{d6dedc93-558f-44fe-90f4-3b4bba8a0b14}"),
    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,
    CID: Components.ID("{ee30d594-0a2d-4f47-89cc-d4cde320ab69}"),
    shouldRegister: false
   },
   // This clearly is non-local
   {scheme: "moz-protocol-loadable-by-anyone",
    flags: Ci.nsIProtocolHandler.URI_LOADABLE_BY_ANYONE,
    CID: Components.ID("{c3735f23-3b0c-4a33-bfa0-79436dcd40b2}"),
    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,
    CID: Components.ID("{b79e977c-f840-469a-b413-0125cc1b62a5}"),
    shouldRegister: true
   },
 ];
 function run_test()
 {
   // Create factories
   let factories = [];
   for (let i = 0; i < testProtocols.length; i++) {
     factories[i] = {
       scheme: testProtocols[i].scheme,
       flags: testProtocols[i].flags,
       CID: testProtocols[i].CID,
       contractID: "@mozilla.org/network/protocol;1?name=" + testProtocols[i].scheme,
       createInstance: function(aOuter, aIID)
       {
         if (aOuter != null)
           throw Cr.NS_ERROR_NO_AGGREGATION;
         let handler = new ProtocolHandler(this.scheme, this.flags, this.CID);
         return handler.QueryInterface(aIID);
       }
     };
   }
   // Add our XULAppInfo factory
   factories.push(XULAppInfoFactory);
   // Register our factories
   for (let i = 0; i < factories.length; i++) {
     let factory = factories[i];
     Components.manager.QueryInterface(Ci.nsIComponentRegistrar)
               .registerFactory(factory.CID, "test-" + factory.scheme,
                                factory.contractID, factory);
   }
   // 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 {
         let ios = Cc["@mozilla.org/network/io-service;1"].
                   getService(Ci.nsIIOService);
         sourceURI = ios.newURI(sourceURI, null, null);
         let uri;
         if (type == "resource") {
           // resources go about a slightly different way than everything else
           let rph = ios.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) {
           do_check_eq(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.
           do_check_neq(expectedURI, uri);
         }
       }
       catch (e) {
         if (protocol.shouldRegister) {
           dump(e + "\n");
           do_throw("Should have registered our URI for protocol " +
                    protocol.scheme);
         }
       }
     }
   }
   // Unregister our factories so we do not leak
   for (let i = 0; i < factories.length; i++) {
     let factory = factories[i];
     Components.manager.QueryInterface(Ci.nsIComponentRegistrar)
               .unregisterFactory(factory.CID, factory);
   }
 }