Question

Background
I have an existing extension designed to accompany a browser-based game (The extension is mine, the game is not). The extension had been scraping the pages as they came in for the data it needed and making ajax requests for taking any actions.

Problem
The game developers recently changed a number of actions on the site to use ajax requests and I am thus far unable to get the data from those requests.

What I have so far

function TracingListener() {
}

TracingListener.prototype =
{
    originalListener: null,
    receivedData: [],   // array for incoming data.

    onDataAvailable: function(request, context, inputStream, offset, count)
    {
       var binaryInputStream = CCIN("@mozilla.org/binaryinputstream;1",
                "nsIBinaryInputStream");
        var storageStream = CCIN("@mozilla.org/storagestream;1", "nsIStorageStream");
        binaryInputStream.setInputStream(inputStream);
        storageStream.init(8192, count, null);

        var binaryOutputStream = CCIN("@mozilla.org/binaryoutputstream;1",
                "nsIBinaryOutputStream");

        binaryOutputStream.setOutputStream(storageStream.getOutputStream(0));

        // Copy received data as they come.
        var data = binaryInputStream.readBytes(count);

        this.receivedData.push(data);

        binaryOutputStream.writeBytes(data, count);
        this.originalListener.onDataAvailable(request, context,storageStream.newInputStream(0), offset, count);
    },

    onStartRequest: function(request, context) {
        this.originalListener.onStartRequest(request, context);
    },

    onStopRequest: function(request, context, statusCode)
    {
        try {
            if (request.originalURI && piratequesting.baseURL == request.originalURI.prePath && request.originalURI.path.indexOf("/index.php?ajax=") == 0) {

                dump("\nProcessing: " + request.originalURI.spec + "\n");
                var date = request.getResponseHeader("Date");

                var responseSource = this.receivedData.join();
                dump("\nResponse: " + responseSource + "\n");

                piratequesting.ProcessRawResponse(request.originalURI.spec, responseSource, date);
            }
        } catch(e) { dumpError(e);}

        this.originalListener.onStopRequest(request, context, statusCode);
    },

    QueryInterface: function (aIID) {
        if (aIID.equals(Ci.nsIStreamListener) ||
            aIID.equals(Ci.nsISupports)) {
            return this;
        }
        throw Components.results.NS_NOINTERFACE;
    }
}


hRO = {

    observe: function(aSubject, aTopic, aData){
        try {
            if (aTopic == "http-on-examine-response") {
                if (aSubject.originalURI && piratequesting.baseURL == aSubject.originalURI.prePath && aSubject.originalURI.path.indexOf("/index.php?ajax=") == 0) {
                    var newListener = new TracingListener();
                    aSubject.QueryInterface(Ci.nsITraceableChannel);
                    newListener.originalListener = aSubject.setNewListener(newListener);

                    dump("\n\nObserver Processing: " + aSubject.originalURI.spec + "\n");
                    for (var i in aSubject) {
                        dump("\n\trequest." + i);
                    }
                }
            }
        } catch (e) {
            dumpError(e);

        }
    },

    QueryInterface: function(aIID){
        if (aIID.equals(Ci.nsIObserver) ||
        aIID.equals(Ci.nsISupports)) {
            return this;
        }

        throw Components.results.NS_NOINTERFACE;

    }
};


var observerService = Cc["@mozilla.org/observer-service;1"] .getService(Ci.nsIObserverService);

observerService.addObserver(hRO, "http-on-examine-response", false);

What’s happening
The above code is notified properly when an http request is processed. The uri is also available and is correct (it passes the domain/path check) but the responseSource that gets dumped is, as far as I can tell, always the contents of the first http request made after the browser opened and, obviously, not what I was expecting.

The code above comes in large part from http://www.softwareishard.com/blog/firebug/nsitraceablechannel-intercept-http-traffic/. I’m really hoping that it’s just something small that I’ve overlooked but I’ve been banging my head against the desk for days on this one, and so now I turn to the wisdom of SO. Any ideas?

Answer 1

but the responseSource that gets
dumped is, as far as I can tell,
always the contents of the first http
request made after the browser opened
and, obviously, not what I was
expecting.

There is a problem with the code above. The “receivedData” member is declared on prototype object and have empty array assigned. This leads to every instantiation of the TracingListener class to be using the same object in memory for receivedData. Changing your code to might solve he problem:

function TracingListener() {
    this.receivedData = [];
}

TracingListener.prototype =
{
    originalListener: null,
    receivedData: null,   // array for incoming data.

/* skipped */

}

Not sure though if this will solve your original problem.