* Updated for Firefox 2REL_1_1_2upstream/master

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);" />

-	</toolbaritem>

+	<textbox id="urlbar" ontextentered="xriFix(); return handleURLBarCommand(param);" />

 

-	<toolbaritem id="go-container">

-		<toolbarbutton id="go-button" oncommand="xriFix(); return handleURLBarCommand(event);" />

-	</toolbaritem>

+	<toolbarbutton id="go-button" oncommand="xriFix(); return handleURLBarCommand(event);" />

 

 </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>