The Tor Browser: netwerk/test/unit/test_fallback_no-cache-entry_canceled.js@6474c204b198 (annotated)

netwerk/test/unit/test_fallback_no-cache-entry_canceled.js@6474c204b198 (annotated)

netwerk/test/unit/test_fallback_no-cache-entry_canceled.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 Cu.import("resource://testing-common/httpd.js");
 var httpServer = null;
 // Need to randomize, because apparently no one clears our cache
 var randomPath = "/redirect/" + Math.random();
 XPCOMUtils.defineLazyGetter(this, "randomURI", function() {
   return "http://localhost:" + httpServer.identity.primaryPort + randomPath;
 });
 var cacheUpdateObserver = null;
 function make_channel(url, callback, ctx) {
   var ios = Cc["@mozilla.org/network/io-service;1"].
             getService(Ci.nsIIOService);
   return ios.newChannel(url, "", null);
 }
 function make_uri(url) {
   var ios = Cc["@mozilla.org/network/io-service;1"].
             getService(Ci.nsIIOService);
   return ios.newURI(url, null, null);
 }
 var responseBody = "Content body";
 // start the test with loading this master entry referencing the manifest
 function masterEntryHandler(metadata, response)
 {
   var masterEntryContent = "<html manifest='/manifest'></html>";
   response.setHeader("Content-Type", "text/html");
   response.bodyOutputStream.write(masterEntryContent, masterEntryContent.length);
 }
 // manifest defines fallback namespace from any /redirect path to /content
 function manifestHandler(metadata, response)
 {
   var manifestContent = "CACHE MANIFEST\nFALLBACK:\nredirect /content\n";
   response.setHeader("Content-Type", "text/cache-manifest");
   response.bodyOutputStream.write(manifestContent, manifestContent.length);
 }
 // content handler correctly returns some plain text data
 function contentHandler(metadata, response)
 {
   response.setHeader("Content-Type", "text/plain");
   response.bodyOutputStream.write(responseBody, responseBody.length);
 }
 // finally check we got fallback content
 function finish_test(request, buffer)
 {
   do_check_eq(buffer, "");
   httpServer.stop(do_test_finished);
 }
 function run_test()
 {
   httpServer = new HttpServer();
   httpServer.registerPathHandler("/masterEntry", masterEntryHandler);
   httpServer.registerPathHandler("/manifest", manifestHandler);
   httpServer.registerPathHandler("/content", contentHandler);
   httpServer.start(-1);
   var pm = Cc["@mozilla.org/permissionmanager;1"]
     .getService(Ci.nsIPermissionManager);
   var uri = make_uri("http://localhost:" + httpServer.identity.primaryPort);
   var principal = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
                     .getService(Ci.nsIScriptSecurityManager)
                     .getNoAppCodebasePrincipal(uri);
   if (pm.testPermissionFromPrincipal(principal, "offline-app") != 0) {
     dump("Previous test failed to clear offline-app permission!  Expect failures.\n");
   }
   pm.addFromPrincipal(principal, "offline-app", Ci.nsIPermissionManager.ALLOW_ACTION);
   var ps = Cc["@mozilla.org/preferences-service;1"]
     .getService(Ci.nsIPrefBranch);
   dump(ps.getBoolPref("browser.cache.offline.enable"));
   ps.setBoolPref("browser.cache.offline.enable", true);
   ps.setComplexValue("browser.cache.offline.parent_directory", Ci.nsILocalFile, do_get_profile());
   cacheUpdateObserver = {observe: function() {
     dump("got offline-cache-update-completed\n");
     // offline cache update completed.
     // In this test the randomURI doesn't exists
     var chan = make_channel(randomURI);
     chan.loadFlags = (Ci.nsIRequest.INHIBIT_CACHING |
                       Ci.nsIRequest.LOAD_FROM_CACHE |
                       Ci.nsICachingChannel.LOAD_ONLY_FROM_CACHE);
     chan.notificationCallbacks = new ChannelEventSink(ES_ABORT_REDIRECT);
     var chanac = chan.QueryInterface(Ci.nsIApplicationCacheChannel);
     chanac.chooseApplicationCache = true;
     chan.asyncOpen(new ChannelListener(finish_test, null, CL_EXPECT_FAILURE), null);
   }}
   var os = Cc["@mozilla.org/observer-service;1"].
            getService(Ci.nsIObserverService);
   os.addObserver(cacheUpdateObserver, "offline-cache-update-completed", false);
   var us = Cc["@mozilla.org/offlinecacheupdate-service;1"].
            getService(Ci.nsIOfflineCacheUpdateService);
   us.scheduleUpdate(make_uri("http://localhost:" +
                              httpServer.identity.primaryPort + "/manifest"),
                     make_uri("http://localhost:" +
                              httpServer.identity.primaryPort + "/masterEntry"),
                     null);
   do_test_pending();
 }