The Tor Browser: netwerk/test/unit/test_traceable_channel.js@ac0c01689b40 (annotated)

netwerk/test/unit/test_traceable_channel.js@ac0c01689b40 (annotated)

netwerk/test/unit/test_traceable_channel.js

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 // Test nsITraceableChannel interface.
 // Replace original listener with TracingListener that modifies body of HTTP
 // response. Make sure that body received by original channel's listener
 // is correctly modified.
 Cu.import("resource://testing-common/httpd.js");
 var httpserver = new HttpServer();
 httpserver.start(-1);
 const PORT = httpserver.identity.primaryPort;
 var pipe = null;
 var streamSink = null;
 var originalBody = "original http response body";
 var gotOnStartRequest = false;
 function TracingListener() {}
 TracingListener.prototype = {
   onStartRequest: function(request, context) {
     dump("*** tracing listener onStartRequest\n");
     gotOnStartRequest = true;
     request.QueryInterface(Components.interfaces.nsIHttpChannelInternal);
 // local/remote addresses broken in e10s: disable for now
 /*
     do_check_eq(request.localAddress, "127.0.0.1");
     do_check_eq(request.localPort > 0, true);
     do_check_neq(request.localPort, PORT);
     do_check_eq(request.remoteAddress, "127.0.0.1");
     do_check_eq(request.remotePort, PORT);
 */
     // Make sure listener can't be replaced after OnStartRequest was called.
     request.QueryInterface(Components.interfaces.nsITraceableChannel);
     try {
       var newListener = new TracingListener();
       newListener.listener = request.setNewListener(newListener);
     } catch(e) {
       dump("TracingListener.onStartRequest swallowing exception: " + e + "\n");
       return; // OK
     }
     do_throw("replaced channel's listener during onStartRequest.");
   },
   onStopRequest: function(request, context, statusCode) {
     dump("*** tracing listener onStopRequest\n");
     do_check_eq(gotOnStartRequest, true);
     try {
       var sin = Components.classes["@mozilla.org/scriptableinputstream;1"].
           createInstance(Ci.nsIScriptableInputStream);
       streamSink.close();
       var input = pipe.inputStream;
       sin.init(input);
       do_check_eq(sin.available(), originalBody.length);
       var result = sin.read(originalBody.length);
       do_check_eq(result, originalBody);
       input.close();
     } catch (e) {
       dump("TracingListener.onStopRequest swallowing exception: " + e + "\n");
     } finally {
       httpserver.stop(do_test_finished);
     }
   },
   QueryInterface: function(iid) {
     if (iid.equals(Components.interfaces.nsIRequestObserver) ||
         iid.equals(Components.interfaces.nsISupports)
         )
       return this;
     throw Components.results.NS_NOINTERFACE;
   },
   listener: null
 }
 function HttpResponseExaminer() {}
 HttpResponseExaminer.prototype = {
   register: function() {
     Cc["@mozilla.org/observer-service;1"].
       getService(Components.interfaces.nsIObserverService).
       addObserver(this, "http-on-examine-response", true);
     dump("Did HttpResponseExaminer.register\n");
   },
   // Replace channel's listener.
   observe: function(subject, topic, data) {
     dump("In HttpResponseExaminer.observe\n");
     try {
       subject.QueryInterface(Components.interfaces.nsITraceableChannel);
       var tee = Cc["@mozilla.org/network/stream-listener-tee;1"].
           createInstance(Ci.nsIStreamListenerTee);
       var newListener = new TracingListener();
       pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
       pipe.init(false, false, 0, 0xffffffff, null);
       streamSink = pipe.outputStream;
       var originalListener = subject.setNewListener(tee);
       tee.init(originalListener, streamSink, newListener);
     } catch(e) {
       do_throw("can't replace listener " + e);
     }
     dump("Did HttpResponseExaminer.observe\n");
   },
   QueryInterface: function(iid) {
     if (iid.equals(Components.interfaces.nsIObserver) ||
         iid.equals(Components.interfaces.nsISupportsWeakReference) ||
         iid.equals(Components.interfaces.nsISupports))
       return this;
     throw Components.results.NS_NOINTERFACE;
   }
 }
 function test_handler(metadata, response) {
   response.setHeader("Content-Type", "text/html", false);
   response.setStatusLine(metadata.httpVersion, 200, "OK");
   response.bodyOutputStream.write(originalBody, originalBody.length);
 }
 function make_channel(url) {
   var ios = Cc["@mozilla.org/network/io-service;1"].
     getService(Ci.nsIIOService);
   return ios.newChannel(url, null, null).
     QueryInterface(Components.interfaces.nsIHttpChannel);
 }
 // Check if received body is correctly modified.
 function channel_finished(request, input, ctx) {
   httpserver.stop(do_test_finished);
 }
 function run_test() {
   var observer = new HttpResponseExaminer();
   observer.register();
   httpserver.registerPathHandler("/testdir", test_handler);
   var channel = make_channel("http://localhost:" + PORT + "/testdir");
   channel.asyncOpen(new ChannelListener(channel_finished), null);
   do_test_pending();
 }