3 files changed, 8 insertions, 14 deletions
diff --git a/src/chrome/content/foxri.xul b/src/chrome/content/foxri.xul
index dc1cc37..785cc0c 100755
--- a/src/chrome/content/foxri.xul
+++ b/src/chrome/content/foxri.xul
@@ -1,32 +1,28 @@
 <?xml version="1.0"?>
 <?xml-stylesheet href="foxri.css" type="text/css"?>
 <overlay id="foxri" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> 
 <!--
 <script type="application/x-javascript" src="chrome://foxri/content/xrdsHandler.js"/>
 -->
 <script>
 function xriFix(event)
 {
        var txt = gURLBar.value;
        if (/^(=|@|!)\S+/.test(txt)) {
                gURLBar.value = "xri://" + txt;
        }
 }
 </script>
-        <toolbaritem id="urlbar-container">
+        <textbox id="urlbar" ontextentered="xriFix(); return handleURLBarCommand(param);" />
-                <textbox id="urlbar" ontextentered="xriFix(); return handleURLBarCommand(param);" />
-        </toolbaritem>
-        <toolbaritem id="go-container">
+        <toolbarbutton id="go-button" oncommand="xriFix(); return handleURLBarCommand(event);" />
-                <toolbarbutton id="go-button" oncommand="xriFix(); return handleURLBarCommand(event);" />
-        </toolbaritem>
 </overlay>
diff --git a/src/components/xriProtocolHandler.js b/src/components/xriProtocolHandler.js
index 7046cde..1105874 100755
--- a/src/components/xriProtocolHandler.js
+++ b/src/components/xriProtocolHandler.js
@@ -126,385 +126,385 @@ function getString(doc, context, expr)
                return res.stringValue;
        return null;
 }
 function getNode(doc, context, expr)
 {
        var res = runExpr(doc, context, expr, XP_FIRST_ORDERED_NODE_TYPE);
        if (res)
                return res.singleNodeValue;
        return null;
 }
 function getFinalXRD(doc)
 {
        var lastNode = doc.firstChild;
        while (true) {
                var node = getNode(doc, lastNode, "xrds:XRDS[position()=last()]");
                if (!node)
                        break;
                lastNode = node;
        }
        return getNode(doc, lastNode, "xrd:XRD[position()=last()]");
 }
 function isIName(xri)
 {
        if (xri.match('^xri://.!', 'i')) {
                return false;
        }
        if (xri.match('^.!', 'i')) {
                return false;
        }
        return true;
 }
 function arraySearch(a, re)
 {
        var returnArr = new Array();
        var i;
        for (i = 0; i < a.length; i++) {
                if (a[i].match(re)) {
                        returnArr.push(a[i]);
                }
        }
        return returnArr;
 }
 function renderService(srv, doc, qxri)
 {
        var html_types = '';
        var html_paths = '';
        var html_mediatypes = '';
        var html_uris = '';
        var html_actions = '';
        var serviceName = friendlyServiceName(null);
        var serviceType; // the last non-null Type
        var knownServiceType; // first recognized service type
        // get the types
        var res = runExpr(doc, srv, "xrd:Type/text()");
        var t;
        while (t = res.iterateNext()) {
                if (t.nodeValue) {
                        if (!knownServiceType && isKnownServiceType(t.nodeValue)) {
                                knownServiceType = t.nodeValue;
                        }
                        serviceType = t.nodeValue;
                        html_types += "<strong>Type:</strong> " + t.nodeValue + "<br/>";
                }
        }
        // get the paths
        res = runExpr(doc, srv, "xrd:Path/text()");
        var p;
        var qxri_prefix = qxri;
        if (qxri_prefix.charAt(qxri_prefix.length - 1) != '/') {
                qxri_prefix += '/';
        }
        while (p = res.iterateNext()) {
                if (p.nodeValue) {
                        html_paths += "<strong>Path:</strong> " + p.nodeValue
                                + " [ <tt><a href=\"" + qxri_prefix + p.nodeValue + "\">"
                                        + qxri_prefix + p.nodeValue + "</a></tt> ]"
                                + "<br/>\n";
                }
        }
        // get the mediatypes
        mediaTypes = new Array();
        res = runExpr(doc, srv, "xrd:MediaType/text()");
        var m;
        while (m = res.iterateNext()) {
                if (!knownServiceType) {
                        var srvType = guessServiceTypeByMime(m.nodeValue);
                        knownServiceType = srvType? srvType : null;
                }
                mediaTypes.push(m.nodeValue);
                if (m.nodeValue) {
                        html_mediatypes += "<strong>Media Type:</strong> " + m.nodeValue + "<br/>";
                }
        }
        res = runExpr(doc, srv, "xrd:URI/text()");
        var u;
        while (u = res.iterateNext()) {
                if (!u.nodeValue)
                        continue;
                var srvType = guessServiceTypeByURI(u.nodeValue);
                if (!knownServiceType) {
                        knownServiceType = srvType;
                }
                html_uris += "<div class=\"" + getServiceClass(srvType) + "\">";
                var linkContent = u.nodeValue;
                var uriParts = u.nodeValue.match('^(.*):(.*)$');
                if (!uriParts)
                        continue;
                if (uriParts[1] == 'data') {
                        uriParts = uriParts[2].match('^(.*/.*),(.*)');
                        if (uriParts && uriParts[1].match('^image/', 'i')) {
                                linkContent = "<img src=\"" + u.nodeValue + "\"/>";
                        }
                        else if (uriParts) {
                                linkContent = uriParts[1] + " data";
                        }
                }
                else if (uriParts[1] == 'skype') {
                        uriParts = uriParts[2].match('^(.*)\\?(.*)');
                        if (uriParts) {
                                if (uriParts[2] == "call") {
                                        linkContent = "<img src=\"chrome://foxri/content/skype_call_large.png\" alt=\"Call " + uriParts[1] + "\"/>";
                                }
                                else if (uriParts[2] == "chat") {
                                        linkContent = "<img src=\"chrome://foxri/content/skype_chat_large.png\" alt=\"Chat with " + uriParts[1] + "\"/>";
                                }
                                else if (uriParts[2] == "add") {
                                        linkContent = "<img src=\"chrome://foxri/content/skype_add_large.png\" alt=\"Add " + uriParts[1] + " to Skype\"/>";
                                }
                        }
                }
                else if (uriParts[1] == 'aim') {
                        uriParts = uriParts[2].match('^(.*)\\?.*screenname=([^&]*)', 'i');
                        if (uriParts) {
                                linkContent = "<img src=\"chrome://foxri/content/aim_logo.gif\" alt=\"Chat with " + uriParts[2] + "\"/> Chat with " + uriParts[2];
                        }
                }
                html_uris += "<a href=\""+u.nodeValue+"\">"
                        + linkContent + "</a>";
                html_uris += "</div>";
        }
        var html = "<div class=\"service srv_" + getServiceClass(knownServiceType) + "\">\n";
        html += html_types;
        html += html_paths;
        html += html_mediatypes;
        if (html_uris) {
                html +=  "<strong>URI(s):</strong><br/>\n";
                html += html_uris;
        }
        html += "</div>";
        return html;
 }
 function isKnownServiceType(type)
 {
        if (type.toLowerCase() in SERVICE_CLASSES) {
                return true;
        }
        return false;
 }
 function getServiceClass(type)
 {
-        if (isKnownServiceType(type)) {
+        if (type && isKnownServiceType(type)) {
                return SERVICE_CLASSES[type.toLowerCase()];
        }
        return type;
 }
 function guessServiceTypeByURI(uri)
 {
        if (uri == null || uri == "") {
                return "unknown";
        }
        if (uri.match(/^https?:/i)) {
                return "www";
        }
        else if (uri.match(/^skype:/i)) {
                return "skype";
        }
        else if (uri.match(/^aim:/i)) {
                return "aim";
        }
        else if (uri.match(/^xmpp:/i)) {
                return "jabber";
        }
        else if (uri.match(/^tel:/i)) {
                return "tel";
        }
        else if (uri.match(/^callto:/i)) {
                return "callto";
        }
        else if (uri.match(/^telnet:/i)) {
                return "telnet";
        }
        else if (uri.match(/^news:/i)) {
                return "news";
        }
        else if (uri.match(/^nntp:/i)) {
                return "nntp";
        }
        else if (uri.match(/^ftp:/i)) {
                return "ftp";
        }
        else if (uri.match(/^mailto:/i)) {
                return "email";
        }
        else if (uri.match(/^urn:/i)) {
                return "urn";
        }
        else if (uri.match(/^data:/i)) {
                return "data";
        }
        else if (uri.match(/^feed:/i)) {
                return "feed";
        }
        return "unknown";
 }
 function guessServiceTypeByMime(mimeType)
 {
        if (mimeType.match(/^application\/(rss|atom)\+xml/i)) {
                dump("feed detected!\n");
                return "feed";
        }
        else if (mimeType.match(/^image\//i)) {
                return "image";
        }
        return null;
 }
 function friendlyServiceName(srvType, uri)
 {
        if (srvType && srvType == "xri://+i-service*(+contact)*($v*1.0)") {
                return "Contact Service";
        }
        else if (srvType && srvType == "http://openid.net/signon/1.0") {
                return "OpenID Authentication Service";
        }
        else if (srvType && srvType == "xri://$res*auth*($v*2.0)") {
                return "Authority Resolution Service";
        }
        else {
                if (uri == null) {
                        return "Generic Service";
                }
                if (uri.match(/^https?:/i)) {
                        return "Web Link";
                }
                else if (uri.match(/^skype:/i)) {
                        var user = uri.substring("skype:".length, uri.indexOf('?'));
                        return "Skype <a href=\"" + uri + "\"><img src=\"chrome://foxri/content/skype_call.png\"></a>";
                }
                else if (uri.match(/^mailto:/i)) {
                        var qmark = uri.indexOf('?');
                        var email = (qmark == -1)?
                                uri.substr("mailto:".length) :
                                uri.substring("mailto:".length, qmark);
                        return "Email (address: " + email + ")";
                }
                else if (srvType != null) {
                        return srvType; // return verbatim
                }
                return "Generic Service";
        }
 }
 function subHTML(template, vars)
 {
        for (key in vars) {
                template = template.replace(key, vars[key], 'g');
        }
        return template;
 }
 /// Given the completed XMLHttpRequest object, renders the XRDS
 function renderXRDS(xmlDoc)
 {
        var x = xmlDoc;
        var qxri = getString(x, x, "/xrds:XRDS/@ref");
        var html = subHTML(HTML_HEAD, { '#QXRI#': qxri });
        // TODO: render parents as well
        var lastNode = getFinalXRD(x);
        if (lastNode) {
                var stat = getString(x, lastNode, "xrd:Status/@code");
                if (stat == "100") {
                        html += "<h3>Exploring <strong>" + qxri + "</strong></h3>";
                }
                else {
                        var msg = getString(x, lastNode, "xrd:Status/text()");
                        html += "<h3 class=\"error\"><strong>" + qxri + "</strong> failed to resolve (reason: " + stat + " - " + msg + ")</h3>";
                }
                html += "<br/>";
                var services = runExpr(x, lastNode, "xrd:Service");
                var s;
                var count = getNumeric(x, lastNode, "count(xrd:Service)");
                if (count > 0) {
                        while (s = services.iterateNext()) {
                                count++;
                                html += renderService(s, x, qxri);
                        }
                }
                else if (stat == '222') {
                        var xriType = isIName(qxri)? 'I-name' : 'I-number';
                        html += "<p class='error'>" + xriType + " does not exist.</p>\n";
                }
                else {
                        html += "<p>No service has been configured for this XRI</p>";
                }
        }
        html += "</html>";
        return html;
 }
 /***********************************************************
  XriServiceExplorer class definition
 ***********************************************************/
 function XRIChannel(uri) {
        this.URI = uri;
        var r = uri.spec.indexOf('#');
        if (r >= 0) {
                this.qxri = uri.spec.substring(0, r);
                this.fragment = uri.spec.substring(r);
        }
        else {
                this.qxri = uri.spec;
        }
 };
 XRIChannel.prototype = {
        fragment: null,
@@ -608,421 +608,419 @@ XRIChannel.prototype = {
        onStartRequest : function(request, ctx)
        {
                dump("\nonStartRequest called\n");
                // XXX
                this.copyFields(request);
                this.asyncOpenListener.onStartRequest(this, this.asyncOpenContext);
        },
        onStopRequest : function(request, ctx, status)
        {
                dump("\nonStopRequest called - status " + status + "\n");
                // XXX
 /*
                this.asyncOpenListener.onStopRequest(this, this.asyncOpenContext, status);
                return;
 */
                this.copyFields(request);
                this.loadDone = true;
                if (status == 0) {
                        var domParser = Components.classes["@mozilla.org/xmlextras/domparser;1"].createInstance(Components.interfaces.nsIDOMParser);
                        var xmlDoc = domParser.parseFromString(this.buf, "text/xml");
                        // make fake inputstream
                        var renderedHTML = renderXRDS(xmlDoc);
                        this.contentCharset = "UTF-8";
                        this.contentLength = renderedHTML.length;
                        this.contentType = "text/html";
                        dump("rendered HTML = \n" + renderedHTML + "\n");
                        dump("\nCalling asyncOpenListener.onStartRequest\n\n");
                        var strIStream = Components.classes["@mozilla.org/io/string-input-stream;1"].createInstance(Components.interfaces.nsIStringInputStream);
                        if (strIStream) {
                                strIStream.setData(renderedHTML, renderedHTML.length);
 /*
                                strIStream.setData(this.buf, this.buf.length);
 */
                                dump("\nleftovers in string-input-stream = " + strIStream.available() + "\n");
                                dump("\nCalling asyncOpenListener.onDataAvailable\n\n");
                                this.asyncOpenListener.onDataAvailable(this, this.asyncOpenContext, strIStream, 0, renderedHTML.length);
 /*
                                this.asyncOpenListener.onDataAvailable(this, this.asyncOpenContext, strIStream, 0, this.buf.length);
 */
                                dump("\nleftovers in string-input-stream = " + strIStream.available() + "\n");
                        }
                }
                else {
                        dump("\nStatus = " + status + "\n");
                        dump("Calling asyncOpenListener.onStartRequest\n\n");
                        this.asyncOpenListener.onStartRequest(this, this.asyncOpenContext);
                }
                dump("stopping request for underlying asyncOpenListener\n");
                this.asyncOpenListener.onStopRequest(this, this.asyncOpenContext, status);
                // copied from nsIWyciwygChannel
                this.asyncOpenListener = null;
                this.asyncOpenContext = null;
 /*
                if (this.loadGroup) {
                        this.loadGroup.removeRequest(request, null, status);
                }
 */
                this.notificationCallbacks = null;
                this.mChannel = null;
                dump("stopped request\n");
        },
 /* public fields (nsIInputStream implementation) */
        available: function()
        {
                dump("nsIInputStream::available called\n");
                return renderedHTML.length;
        },
        close: function()
        {
                dump("nsIInputStream::close called\n");
        },
        isNonBlocking: function() {
                dump("nsIInputStream::isNonBlocking called\n");
                return true;
        },
        read: function() { dump("nsIInputStream::read() called!!!\n"); },
 /* public fields (nsIRequest implmentation) */
        loadFlags: 0,
        loadGroup: null,
        name: "xri://request",
        status: 0,
        cancel: function(status) { dump("\ncancel called...\n"); },
        isPending: function() {
                dump("isPending called\n\n");
                return !this.loadDone;
        },
        resume: function() { dump("resume called\n"); },
        suspend: function() { dump("suspend called\n"); },
 /* public fields (nsIChannel implmentation) */
        contentCharset: null,
        contentLength: -1,
        contentType: null,
        notificationCallbacks: null,
        originalURI: null,
        owner: null,
        securityInfo: null,
        URI: null,
        open: function()
        {
                dump("open not supporteD!!!!!!\n");
        },
        asyncOpen: function(listener, context)
        {
                dump("asyncOpen called!!!!!!\n");
                this.asyncOpenListener = listener;
                this.asyncOpenContext = context;
                var hxri = PROXY_URI + this.qxri
                        + "?_xrd_r=application/xrds%2Bxml;sep=false";
                var ioService = Components.classesByID[kIOSERVICE_CID_STR].getService();
                ioService = ioService.QueryInterface(nsIIOService);
                var channel = ioService.newChannel(hxri, null, null);
                if (this.scriptableInStream) {
                        dump("Hey! You can't possibly be reusing this handler?!\n");
                        return;
                }
                dump("making scriptableInStream\n");
                this.scriptableInStream = Components.classes["@mozilla.org/scriptableinputstream;1"]
                        .createInstance(Components.interfaces.nsIScriptableInputStream);
                this.buf = '';
                dump("notificationCallbacks = " + this.notificationCallbacks + "\n");
                dump("loadFlags = " + this.loadFlags + "\n");
                dump("loadGroup = " + this.loadGroup + "\n");
                dump("owner = " + this.owner + "\n");
                dump("securityInfo = " + this.securityInfo + "\n");
                // these nsIRequest attributes must be copied to the stub
                // channel that we created
                channel.notificationCallbacks = this.notificationCallbacks;
                channel.loadGroup = this.loadGroup;
                channel.loadFlags = this.loadFlags;
                this.mChannel = channel;
                channel.asyncOpen(this, null);
        },
-/* public fields (nsIChannel implmentation) */
+/* public fields (nsIChannel implementation) */
        allowPipelining: false,
        redirectionLimit: 5,
        referrer: "",
        requestMethod: "GET",
        requestSucceeded: true,
        responseStatus: 200,
        responseStatusText: "OK",
        getRequestHeader: function(header) {
                dump("getRequestHeader(" + header + ")\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                try {
                        var val = httpChannel.getRequestHeader(header);
                        dump("getRequestHeader(" + header + ") = " + val + "\n");
                        return val;
                }
                catch (e) {
+                        dump("getRequestHeader - got exception: " + e + "\n");
                        throw e;
                }
        },
        getResponseHeader: function(header) {
                dump("getResponseHeader(" + header + ")\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                try {
                        var val = httpChannel.getResponseHeader(header);
                        dump("getResponseHeader(" + header + ") = " + val + "\n");
                        return val;
                }
                catch (e) {
+                        dump("getResponseHeader - got exception: " + e + "\n");
                        throw e;
                }
-/* XXX
-                if (header == "Content-Type")
-                        return "text/html";
-*/
                return null;
        },
        isNoCacheResponse: function() {
                dump("isNoCacheResponse()\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                return httpChannel.isNoCacheResponse();
        },
        isNoStoreResponse: function() {
                dump("isNoStoreResponse()\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                return httpChannel.isNoStoreResponse();
                return true;
        },
        setRequestHeader: function(header, value, merge) {
                dump("setRequestHeader(" + header + ", " + value + ")\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                return httpChannel.setRequestHeader(header, value, merge);
        },
        setResponseHeader: function(header, value, merge) {
                dump("setResponseHeader(" + header + ", " + value + ")\n");
                var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
                return httpChannel.setResponseHeader(header, value, merge);
        },
        visitRequestHeaders: function(visitor) {
                dump("visitRequestHeaders()\n");
        },
        visitResponseHeaders: function(visitor) {
                dump("visitResponseHeaders()\n");
        },
        QueryInterface: function(iid)
        {
                dump("QI.. \n");
                if (iid.equals(nsIChannel))
                        dump("QI(nsIChannel)\n");
                else if (iid.equals(nsIHttpChannel))
                        dump("QI(nsIHttpChannel)\n");
                else if (iid.equals(Components.interfaces.nsIUploadChannel))
                        dump("QI(nsIUploadChannel) - not supported\n");
                else if (iid.equals(Components.interfaces.nsICachingChannel))
                        dump("QI(nsICachingChannel) - not supported\n");
                else if (iid.equals(Components.interfaces.nsIClassInfo))
                        dump("QI(nsIClassInfo) - not supported\n");
                else if (iid.equals(Components.interfaces.nsISecurityCheckedComponent))
                        dump("QI(nsISecurityCheckedComponent) - not supported\n");
                else if (iid.equals(Components.interfaces.nsIWyciwygChannel))
                        dump("QI(nsIWyciwygChannel) - not supported\n");
                else if (iid.equals(Components.interfaces.nsIMultiPartChannel))
                        dump("QI(nsIMultiPartChannel) - not supported\n");
                else if (iid.equals(Components.interfaces.nsIHttpChannelInternal))
                        dump("QI(nsIHttpChannelInternal) - not supported\n");
                else if (iid.equals(Components.interfaces.nsIWritablePropertyBag2))
                        dump("QI(nsIWritablePropertyBag2) - not supported\n");
                else if (iid.equals(nsIRequest))
                        dump("QI(nsIRequest)\n");
                else if (iid.equals(nsIRequestObserver))
                        dump("QI(nsIRequestObserver)\n");
                else if (iid.equals(nsISupports))
                        dump("QI(nsISupports)\n");
                else if (iid.equals(nsIStreamListener))
                        dump("QI(nsIStreamListener)\n");
                else
                        dump("unknown " + iid + "\n");
                if (iid.equals(nsISupports) ||
                                iid.equals(nsIRequest) ||
                                iid.equals(nsIRequestObserver) ||
                                iid.equals(nsIChannel) ||
                                iid.equals(nsIHttpChannel) ||
                                iid.equals(nsIStreamListener)
                   ) {
                        return this;
                }
                throw Components.results.NS_ERROR_NO_INTERFACE;
        }
 };
 /***********************************************************
  XriProtocolHandler class definition
 ***********************************************************/
 //class constructor
 function XriProtocolHandler() {
 };
 // class definition
 XriProtocolHandler.prototype = {
        defaultPort: 80, // HTTP
        protocolFlags : nsIProtocolHandler.ALLOWS_PROXY | nsIProtocolHandler.ALLOWS_PROXY_HTTP,
        scheme: "xri",
        allowPort: function() {
                return false; // only called for blacklisted ports, should respect
        },
        _newHttpChannel: function(aURI)
        {
                var HXRI = PROXY_URI + aURI.spec;
                var ioService = Components.classesByID[kIOSERVICE_CID_STR].getService();
                ioService = ioService.QueryInterface(nsIIOService);
                var channel = ioService.newChannel(HXRI, null, null);
                return channel;
        },
        newChannel: function(aURI)
        {
                // leave alone if path is not empty or just a single slash or query exists
                dump("path='" + aURI.path + "'\n");
                dump("query='" + aURI.query + "'\n");
                dump("spec='" + aURI.spec + "'\n");
                var slashPos = aURI.spec.indexOf('/', 'xri://'.length);
                var qmarkPos = aURI.spec.indexOf('?');
                dump("slashPos='" + slashPos + "'\n");
                dump("qmarkPos='" + qmarkPos + "'\n");
                if ((slashPos > 0 && slashPos < aURI.spec.length - 1) || qmarkPos > -1) {
                        return this._newHttpChannel(aURI);
                }
                var explorer = new XRIChannel(aURI);
                return explorer;
        },
        newURI: function(spec, originCharset, baseURI)
        {
                var newSpec = spec;
                if (baseURI != null) {
                        // standard-url (nsIURL) does not work with @-GCS
                        var baseURL = Components.classes[CID_URL].createInstance(nsIURL);
                        baseURL.spec = baseURI.spec;
                        newSpec = baseURL.resolve(spec);
                }
                var uri = Components.classes[CID_URI].createInstance(nsIURI);
                uri.spec = newSpec;
                return uri;
        },
        QueryInterface: function(aIID)
        {
                if (!aIID.equals(nsIProtocolHandler) &&    
                                !aIID.equals(nsISupports))
                        throw Components.results.NS_ERROR_NO_INTERFACE;
                return this;
        }
 };
 /***********************************************************
  class factory
  This object is a member of the global-scope Components.classes.
  It is keyed off of the contract ID. Eg:
  myXriProtocolHandler = Components.classes["@dietrich.ganx4.com/helloworld;1"].
  createInstance(Components.interfaces.nsIXriProtocolHandler);
 ***********************************************************/
 var XriProtocolHandlerFactory = {
        createInstance: function (aOuter, aIID)
        {
                if (aOuter != null)
                        throw Components.results.NS_ERROR_NO_AGGREGATION;
                return (new XriProtocolHandler()).QueryInterface(aIID);
        }
 };
 /***********************************************************
  module definition (xpcom registration)
 ***********************************************************/
 var XriProtocolHandlerModule = {
        _firstTime: true,
        registerSelf: function(aCompMgr, aFileSpec, aLocation, aType)
        {
                if (this._firstTime) {
                        this._firstTime = false;
                        throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
                }
                aCompMgr = aCompMgr.
                        QueryInterface(Components.interfaces.nsIComponentRegistrar);
                aCompMgr.registerFactoryLocation(CLASS_ID, CLASS_NAME, 
                        CONTRACT_ID, aFileSpec, aLocation, aType);
diff --git a/src/install.rdf b/src/install.rdf
index a482755..507420c 100755
--- a/src/install.rdf
+++ b/src/install.rdf
@@ -1,40 +1,40 @@
 <?xml version="1.0"?>
 <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
  <Description about="urn:mozilla:install-manifest">
    <em:id>foxri@foxri.net</em:id>
-    <em:version>1.1.1</em:version>
+    <em:version>1.1.2</em:version>
    <em:type>2</em:type>
   
    <!-- Target Application this extension can install into, 
         with minimum and maximum supported versions. --> 
    <em:targetApplication>
      <Description>
        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
        <em:minVersion>1.0</em:minVersion>
-        <em:maxVersion>1.5.0.*</em:maxVersion>
+        <em:maxVersion>2.0.*</em:maxVersion>
      </Description>
    </em:targetApplication>
   
    <em:targetApplication>
      <Description>
        <em:id>{a463f10c-3994-11da-9945-000d60ca027b}</em:id>
        <em:minVersion>0.5</em:minVersion>
        <em:maxVersion>0.8</em:maxVersion>
      </Description>
    </em:targetApplication>
   
    <!-- Front End MetaData -->
    <em:name>FoXRI</em:name>
    <em:description>XRI Extension</em:description>
    <em:creator>William Tan</em:creator>
    <em:homepageURL>http://dready.org/projects/foxri</em:homepageURL>
 <!--
    <em:updateURL>http://dready.org/projects/foxri/update.rdf</em:updateURL>
 -->
  </Description>
 </RDF>