The Tor Browser: netwerk/test/unit/test_seer.js@deefc01c0e14 (annotated)

netwerk/test/unit/test_seer.js@deefc01c0e14 (annotated)

netwerk/test/unit/test_seer.js

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 var Cc = Components.classes;
 var Ci = Components.interfaces;
 var Cu = Components.utils;
 var Cr = Components.results;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/FileUtils.jsm");
 var seer = null;
 var ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
 var profile = null;
 function extract_origin(uri) {
   var o = uri.scheme + "://" + uri.asciiHost;
   if (uri.port !== -1) {
     o = o + ":" + uri.port;
   }
   return o;
 }
 var LoadContext = function _loadContext() {
 };
 LoadContext.prototype = {
   usePrivateBrowsing: false,
   getInterface: function loadContext_getInterface(iid) {
     return this.QueryInterface(iid);
   },
   QueryInterface: function loadContext_QueryInterface(iid) {
     if (iid.equals(Ci.nsINetworkSeerVerifier) ||
         iid.equals(Ci.nsILoadContext)) {
       return this;
     }
     throw Cr.NS_ERROR_NO_INTERFACE;
   }
 };
 var load_context = new LoadContext();
 var Verifier = function _verifier(testing, expected_preconnects, expected_preresolves) {
   this.verifying = testing;
   this.expected_preconnects = expected_preconnects;
   this.expected_preresolves = expected_preresolves;
 };
 Verifier.prototype = {
   verifying: null,
   expected_preconnects: null,
   expected_preresolves: null,
   getInterface: function verifier_getInterface(iid) {
     return this.QueryInterface(iid);
   },
   QueryInterface: function verifier_QueryInterface(iid) {
     if (iid.equals(Ci.nsINetworkSeerVerifier) ||
         iid.equals(Ci.nsISupports)) {
       return this;
     }
     throw Cr.NS_ERROR_NO_INTERFACE;
   },
   maybe_run_next_test: function verifier_maybe_run_next_test() {
     if (this.expected_preconnects.length === 0 &&
         this.expected_preresolves.length === 0) {
       do_check_true(true, "Well this is unexpected...");
       run_next_test();
     }
   },
   onPredictPreconnect: function verifier_onPredictPreconnect(uri) {
     var origin = extract_origin(uri);
     var index = this.expected_preconnects.indexOf(origin);
     if (index == -1) {
       do_check_true(false, "Got preconnect for unexpected uri " + origin);
     } else {
       this.expected_preconnects.splice(index, 1);
     }
     this.maybe_run_next_test();
   },
   onPredictDNS: function verifier_onPredictDNS(uri) {
     var origin = extract_origin(uri);
     var index = this.expected_preresolves.indexOf(origin);
     if (index == -1) {
       do_check_true(false, "Got preresolve for unexpected uri " + origin);
     } else {
       this.expected_preresolves.splice(index, 1);
     }
     this.maybe_run_next_test();
   }
 };
 function reset_seer() {
   seer.reset();
 }
 function newURI(s) {
   return ios.newURI(s, null, null);
 }
 function test_link_hover() {
   reset_seer();
   var uri = newURI("http://localhost:4444/foo/bar");
   var referrer = newURI("http://localhost:4444/foo");
   var preconns = ["http://localhost:4444"];
   var verifier = new Verifier("hover", preconns, []);
   seer.predict(uri, referrer, seer.PREDICT_LINK, load_context, verifier);
 }
 function test_pageload() {
   reset_seer();
   var toplevel = "http://localhost:4444/index.html";
   var subresources = [
     "http://localhost:4444/style.css",
     "http://localhost:4443/jquery.js",
     "http://localhost:4444/image.png"
   ];
   var tluri = newURI(toplevel);
   seer.learn(tluri, null, seer.LEARN_LOAD_TOPLEVEL, load_context);
   var preconns = [];
   for (var i = 0; i < subresources.length; i++) {
     var sruri = newURI(subresources[i]);
     seer.learn(sruri, tluri, seer.LEARN_LOAD_SUBRESOURCE, load_context);
     preconns.push(extract_origin(sruri));
   }
   var verifier = new Verifier("pageload", preconns, []);
   seer.predict(tluri, null, seer.PREDICT_LOAD, load_context, verifier);
 }
 function test_redirect() {
   reset_seer();
   var initial = "http://localhost:4443/redirect";
   var target = "http://localhost:4444/index.html";
   var subresources = [
     "http://localhost:4444/style.css",
     "http://localhost:4443/jquery.js",
     "http://localhost:4444/image.png"
   ];
   var inituri = newURI(initial);
   var targeturi = newURI(target);
   seer.learn(inituri, null, seer.LEARN_LOAD_TOPLEVEL, load_context);
   seer.learn(targeturi, inituri, seer.LEARN_LOAD_REDIRECT, load_context);
   seer.learn(targeturi, null, seer.LEARN_LOAD_TOPLEVEL, load_context);
   var preconns = [];
   preconns.push(extract_origin(targeturi));
   for (var i = 0; i < subresources.length; i++) {
     var sruri = newURI(subresources[i]);
     seer.learn(sruri, targeturi, seer.LEARN_LOAD_SUBRESOURCE, load_context);
     preconns.push(extract_origin(sruri));
   }
   var verifier = new Verifier("redirect", preconns, []);
   seer.predict(inituri, null, seer.PREDICT_LOAD, load_context, verifier);
 }
 function test_startup() {
   reset_seer();
   var uris = [
     "http://localhost:4444/startup",
     "http://localhost:4443/startup"
   ];
   var preconns = [];
   for (var i = 0; i < uris.length; i++) {
     var uri = newURI(uris[i]);
     seer.learn(uri, null, seer.LEARN_STARTUP, load_context);
     preconns.push(extract_origin(uri));
   }
   var verifier = new Verifier("startup", preconns, []);
   seer.predict(null, null, seer.PREDICT_STARTUP, load_context, verifier);
 }
 // A class used to guarantee serialization of SQL queries so we can properly
 // update last hit times on subresources to ensure the seer tries to do DNS
 // preresolve on them instead of preconnecting
 var DnsContinueVerifier = function _dnsContinueVerifier(subresource, tluri, preresolves) {
   this.subresource = subresource;
   this.tluri = tluri;
   this.preresolves = preresolves;
 };
 DnsContinueVerifier.prototype = {
   subresource: null,
   tluri: null,
   preresolves: null,
   getInterface: function _dnsContinueVerifier_getInterface(iid) {
     return this.QueryInterface(iid);
   },
   QueryInterface: function _dnsContinueVerifier_QueryInterface(iid) {
     if (iid.equals(Ci.nsISupports) ||
         iid.equals(Ci.nsINetworkSeerVerifier)) {
       return this;
     }
     throw Cr.NS_ERROR_NO_INTERFACE;
   },
   onPredictPreconnect: function _dnsContinueVerifier_onPredictPreconnect() {
     // This means that the seer has learned and done our "checkpoint" prediction
     // Now we can get on with the prediction we actually want to test
     // tstamp is 10 days older than now - just over 1 week, which will ensure we
     // hit our cutoff for dns vs. preconnect. This is all in usec, hence the
     // x1000 on the Date object value.
     var tstamp = (new Date().valueOf() * 1000) - (10 * 86400 * 1000000);
     seer.prepareForDnsTest(tstamp, this.subresource);
     var verifier = new Verifier("dns", [], this.preresolves);
     seer.predict(this.tluri, null, seer.PREDICT_LOAD, load_context, verifier);
   },
   onPredictDNS: function _dnsContinueVerifier_onPredictDNS() {
     do_check_true(false, "Shouldn't have gotten a preresolve prediction here!");
   }
 };
 function test_dns() {
   reset_seer();
   var toplevel = "http://localhost:4444/index.html";
   var subresource = "http://localhost:4443/jquery.js";
   var tluri = newURI(toplevel);
   seer.learn(tluri, null, seer.LEARN_LOAD_TOPLEVEL, load_context);
   var sruri = newURI(subresource);
   seer.learn(sruri, tluri, seer.LEARN_LOAD_SUBRESOURCE, load_context);
   var preresolves = [extract_origin(sruri)];
   var continue_verifier = new DnsContinueVerifier(subresource, tluri, preresolves);
   // Fire off a prediction that will do preconnects so we know when the seer
   // thread has gotten to the point where we can update the database manually
   seer.predict(tluri, null, seer.PREDICT_LOAD, load_context, continue_verifier);
 }
 function test_origin() {
   reset_seer();
   var toplevel = "http://localhost:4444/index.html";
   var subresources = [
     "http://localhost:4444/style.css",
     "http://localhost:4443/jquery.js",
     "http://localhost:4444/image.png"
   ];
   var tluri = newURI(toplevel);
   seer.learn(tluri, null, seer.LEARN_LOAD_TOPLEVEL, load_context);
   var preconns = [];
   for (var i = 0; i < subresources.length; i++) {
     var sruri = newURI(subresources[i]);
     seer.learn(sruri, tluri, seer.LEARN_LOAD_SUBRESOURCE, load_context);
     var origin = extract_origin(sruri);
     if (preconns.indexOf(origin) === -1) {
       preconns.push(origin);
     }
   }
   var loaduri = newURI("http://localhost:4444/anotherpage.html");
   var verifier = new Verifier("origin", preconns, []);
   seer.predict(loaduri, null, seer.PREDICT_LOAD, load_context, verifier);
 }
 var tests = [
   test_link_hover,
   test_pageload,
   test_redirect,
   test_startup,
   test_dns,
   test_origin
 ];
 function run_test() {
   tests.forEach(add_test);
   profile = do_get_profile();
   seer = Cc["@mozilla.org/network/seer;1"].getService(Ci.nsINetworkSeer);
   do_register_cleanup(reset_seer);
   run_next_test();
 }