...createElementNS ("http://www.w3.org/1999/xhtml", ...);

<tree flex="1">
  <treecols>
    <treecol id="sender" label="Sender" flex="1"/>
    <splitter class="tree-splitter"/>
    <treecol id="subject" label="Subject" flex="2"/>
  </treecols>
  <treechildren id="tc">
  <script type="application/x-javascript" src="chrome://<package_name>/content/script_name.js"/>  
    </treechildren>
</tree>

const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
var tr_ch=document.getElementById("tc");
var i;
for (i=0;i<10;i++)
{
var it=document.createElementNS(XUL_NS, "treeitem"); // create a new XUL treeitem
var r=document.createElementNS(XUL_NS, "treerow"); // create a new XUL treerow
var cel1=document.createElementNS(XUL_NS, "treecell"); // create a new XUL treecell
cel1.setAttribute("label","col1 row"+i);
var cel2=document.createElementNS(XUL_NS, "treecell"); // create a new XUL treecell
cel2.setAttribute("label","col2 row"+i);
tr_ch.appendChild(it);
it.appendChild(r);
r.insertBefore(cel1,r.cel);
r.appendChild(cel2);
}

try {

    //largely from firebug. should refactor 
    if (typeof Cc == "undefined") {
        var Cc = Components.classes;
        var Ci = Components.interfaces;
    }
    if (typeof CCIN == "undefined") {
        function CCIN(cName, ifaceName){
            return Cc[cName].createInstance(Ci[ifaceName]);
        }
    }
    if (typeof CCSV == "undefined") {
        function CCSV(cName, ifaceName){
            if (Cc[cName]) 
                return Cc[cName].getService(Ci[ifaceName]); // if fbs fails to load, the error can be _CC[cName] has no properties
            else 
                dump("CCSV fails for cName:" + cName); 
        };
    }
     
    function TracingListener() {
        //this.receivedData = [];
    }
        
    TracingListener.prototype =
    {
        originalListener: null,
        receivedData: null,   // 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);
            //var data = inputStream.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.receivedData = [];
            this.originalListener.onStartRequest(request, context);
        },
    
        onStopRequest: function(request, context, statusCode)
        {
            try {
                request.QueryInterface(Ci.nsIHttpChannel);
            dump(request.originalURI.path);
                if (request.originalURI && 
                        request.originalURI.path.indexOf("/api/json/getBootstrapData.do") == 0) {
                    
                    //for(opt in request) {
                    //    dump("\nrequest."+opt);
                    //}
                    //dump(request.responseText);
                    var data = null;
                    if(request.requestMethod.toLowerCase() == "post") {
                        var postText = this.readPostTextFromRequest(request,context);
                        if (postText)  
                            data = ((String)(postText)).parseQuery();
                            
                    }
                    //dump("\nProcessing: " + request.originalURI.spec + "\n");
                    var date = Date.parse(request.getResponseHeader("Date"));
                    var responseSource = this.receivedData.join();
                    //fix leading spaces bug
                    responseSource = responseSource.replace(/^\s+(\S[\s\S]+)/,"$1");
                    responseSource = responseSource.replace(/\"testDelay\":8/gm,'"testDelay":0');
                }
            } catch(e) { dump(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;
        },
        readPostTextFromRequest : function(request, context) {
            try
            {
                var is = request.QueryInterface(Ci.nsIUploadChannel).uploadStream;
                if (is)
                {
                    var ss = is.QueryInterface(Ci.nsISeekableStream);
                    var prevOffset;
                    if (ss)
                    {
                        prevOffset = ss.tell();
                        ss.seek(Ci.nsISeekableStream.NS_SEEK_SET, 0);
                    }
        
                    // Read data from the stream..
                    var charset = "UTF-8";
                    var text = this.readFromStream(is, charset, true);
        
                    // Seek locks the file so, seek to the beginning only if necko hasn't read it yet,
                    // since necko doesn't seek to 0 before reading (at lest not till 459384 is fixed).
                    if (ss && prevOffset == 0) 
                        ss.seek(Ci.nsISeekableStream.NS_SEEK_SET, 0);
        
                    return text;
                }
                else {
                    dump("Failed to Query Interface for upload stream.\n");
                }
            }
            catch(exc)
            {
                dump(exc);
            }
        
            return null;
        },
        readFromStream : function(stream, charset, noClose)    {
            
            var sis = CCSV("@mozilla.org/binaryinputstream;1", "nsIBinaryInputStream");
            sis.setInputStream(stream);
        
            var segments = [];
            for (var count = stream.available(); count; count = stream.available())
                segments.push(sis.readBytes(count));
        
            if (!noClose)
                sis.close();
        
            var text = segments.join("");
            return text;
        }
        
    }


    hRO = {

        observe: function(request, aTopic, aData){
            try {
                if (aTopic == "http-on-examine-response") {
                    request.QueryInterface(Ci.nsIHttpChannel);
                    
                dump(request.originalURI.path);
                    if (request.originalURI && 
                            request.originalURI.path.indexOf("/api/json/getBootstrapData.do") == 0) {
                        var newListener = new TracingListener();
                        request.QueryInterface(Ci.nsITraceableChannel);
                        newListener.originalListener = request.setNewListener(newListener);
                    }
                }
            } catch (e) {
                dump(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);
    
} catch (e) { dump(e);}