Reorganized files, divided background into modules.

background/api-impl.js

@@ -0,0 +1,196 @@
+/* Site type
+
+site : The domain (or domain pattern) of the site
+status : One of 'secure', 'potential', 'blacklist'
+
+*/
+
+var API = {
+	'site.all': function() {
+		var rv = [];
+		jsonStorage.each(function(site, data) {
+			if (site[0] == '$') return;
+			data.site = site;
+			rv.push(data);
+		});
+		return rv;
+	},
+	'site.get': function(args) {
+		var site = jsonStorage.get(args.site);
+		if (site) {
+			site.site = args.site;
+		}
+		return site;
+	},
+	'site.add': function(args) {
+		console.assert(args.site[0] != '$');
+		console.assert(args.status);
+		if (jsonStorage.has(args.site)) return false;
+		jsonStorage.set(args.site, args);
+		RaiseEvent('site', 'add', args);
+		return true;
+	},
+	'site.set': function(args) {
+		console.assert(args.site[0] != '$');
+		console.assert(args.status);
+		var data = jsonStorage.get(args.site);
+		if (!data) return false;
+		var changed = false
+		for (k in args) {
+			if (k[0] == '$') continue;
+			if (data[k] != args[k]) {
+				data[k] = args[k];
+				changed = true;
+			}
+		}
+		if (changed) {
+			jsonStorage.set(args.site, data);
+			RaiseEvent('site', 'set', data);
+		}
+		return true;
+	},
+	/// Does either an add or a set, depending on what's needed.
+	'site.makeItSo': function(args) {
+		console.assert(args.site[0] != '$');
+		console.assert(args.status);
+		var data = jsonStorage.get(args.site);
+		var added = false;
+		if (!data) {
+			data = {};
+			added = true;
+		}
+		var changed = false
+		for (k in args) {
+			if (k[0] == '$') continue;
+			if (data[k] != args[k]) {
+				data[k] = args[k];
+				changed = true;
+			}
+		}
+		if (changed) {
+			jsonStorage.set(args.site, data);
+			if (added) {
+				RaiseEvent('site', 'add', data);
+			} else {
+				RaiseEvent('site', 'set', data);
+			}
+		}
+		return true;
+	},
+	'site.del': function(args) {
+		var had = jsonStorage.has(args.site);
+		jsonStorage.del(args.site);
+		if (had) {
+			RaiseEvent('site', 'del', {site:args.site});
+		}
+	},
+	'site.match': function(args) {
+		var site = args.site;
+		var rv = jsonStorage.get(site);
+		if (!rv) {
+			rv = jsonStorage.get("*."+site);
+		}
+		while (!rv) {
+			var i = site.indexOf('.');
+			if (i == -1) return;
+			site = site.substr(i+1);
+			rv = jsonStorage.get("*."+site);
+		}
+		return rv;
+	},
+	'setting.get': function(args) {
+		return jsonStorage.get('$'+args.name);
+	},
+	'setting.set': function(args) {
+		var sname = '$'+args.name;
+		var old = jsonStorage.get(sname);
+		jsonStorage.set('$'+args.name, args.value)
+		if (old != args.value) {
+			RaiseEvent('setting', 'set', {name:args.name, value:args.value});
+			return true;
+		} else {
+			return false;
+		}
+	},
+	'setting.del': function(args) {
+		var sname = '$'+args.name;
+		var had = jsonStorage.has(sname);
+		jsonStorage.del(sname)
+		if (had) {
+			RaiseEvent('setting', 'del', {name:args.name});
+		}
+	},
+	'setting.has': function(args) {
+		return jsonStorage.has('$'+args.name);
+	},
+	'haspotential': function(args, response) {
+		testUrlForHttps(args.site, function(hasit) {
+			response(hasit);
+		});
+		return {$async: true};
+	},
+};
+
+function onRequest(request, sender, sendResponse) {
+	console.log("Request: ", request);
+	var func = request.$name;
+	if (func[0] == '$' || !API[func]) {
+		sendResponse({$error: new ReferenceError(func + " is not a valid API method")});
+		return;
+	}
+	var rv = API[func](request, sendResponse);
+	if (typeof rv == 'object' && rv.$async) {
+		// The function will handle calling the response when it's ready.
+	} else {
+		sendResponse(rv);
+	}
+}
+chrome.extension.onRequest.addListener(onRequest);
+chrome.extension.onRequestExternal.addListener(onRequest);
+
+var events = {
+	'*': [],
+	'site': [],
+	'site.add': [],
+	'site.set': [],
+	'site.del': [],
+	'setting': [],
+	'setting.set': [],
+	'setting.del': [],
+};
+
+function onConnect(port) {
+	var name = '*';
+	if (port.name) {
+		name = port.name;
+	}
+	events[name].push(port);
+	port.onDisconnect.addListener(function() {
+		var i = events[name].indexOf(port);
+		delete events[name][i];
+	});
+}
+chrome.extension.onConnect.addListener(onConnect);
+chrome.extension.onConnectExternal.addListener(onConnect);
+
+function localConnect(name, func) {
+	events[name].push(func);
+}
+
+function RaiseEvent(obj, event, args) {
+	args.$object = obj;
+	args.$event = event;
+	args.$name = obj+'.'+event;
+
+	function callit(port, i, e) {
+		if (port.postMessage) {
+			port.postMessage(args);
+		} else {
+			port(args);
+		}
+	}
+	events['*'].forEach(callit);
+	events[args.$object].forEach(callit);
+	events[args.$name].forEach(callit);
+}
+

background/index.html

@@ -0,0 +1,66 @@
+<script src="jsonstore.js"></script>
+<script src="sitepile.js"></script>
+<script src="api-impl.js"></script>
+<script src="tabs.js"></script>
+<script src="requests.js"></script>
+<script>
+// Initialize stored values
+init();
+
+// Remove this after 3-28-2012
+function migrate() {
+	jsonStorage.set('$enabled', jsonStorage.get('is-disabled'));
+	jsonStorage.get('potential-sites').forEach(function(site) {
+		jsonStorage.set(site, {site: site, status: 'potential'});
+	});
+	jsonStorage.get('sites').forEach(function(site) {
+		jsonStorage.set(site, {site: site, status: 'secure'});
+	});
+	// Not migrating blacklist because we largely don't need it, and it's likely to cause problems
+	jsonStorage.del('is-disabled');
+	jsonStorage.del('enable-page-action');
+	jsonStorage.del('potential-sites');
+	jsonStorage.del('sites');
+	jsonStorage.del('do-not-redirect');
+}
+
+function init() {
+	if (jsonStorage.has('sites')) {
+		migrate();
+	}
+
+	jsonStorage.setDefault('$enabled', true);
+
+	UpdateAllTabs();
+}
+
+var urlCache = {};
+//FIXME: Detect when a duplicate request comes in before the first finishes.
+function testUrlForHttps(url, callback) {
+	if (urlCache[url] != null) {
+		callback(urlCache[url]);
+		return;
+	}
+	var xhr = new XMLHttpRequest();
+	xhr.open('HEAD', 'https://' + url, true);
+
+	//FIXME: Detect redirects
+	xhr.onreadystatechange = function(data) {
+
+		if (xhr.readyState == 4) {
+
+			if (xhr.status == 200) {
+				urlCache[url] = true;
+				callback(true);
+			}
+			else {
+				urlCache[url] = false;
+				callback(false);
+			}
+		}
+	}
+
+	xhr.send();
+}
+
+</script>

background/requests.js

@@ -0,0 +1,102 @@
+function doPotentialSite(po) {
+	testUrlForHttps(po.o, function(hasHttps) {
+		if (hasHttps) {
+			console.log("Potential site: "+po.o);
+			API['site.add']({site:po.o, status:'potential'});
+		}
+	});
+}
+
+var requests = {};
+
+function onBeforeRequest(request) {
+	if (!request) return {}; // on handlerBehaviorChanged() 
+
+	var enabled = API['setting.get']({name:'enabled'});
+	if (!enabled) return {};
+	const rId = request.requestId;
+	console.group("Request:", rId, request.url);
+	console.log(request);
+	if (!requests[rId]) {
+		requests[rId] = {};
+	} else if (requests[rId][request.url]) {
+		console.group("Loop detected");
+		console.log(request.url);
+		console.log(requests[rId]);
+		console.groupEnd();
+		console.groupEnd();
+		return {};
+	}
+	requests[rId][request.url] = true;
+
+	var po = new ProtoOrigin(request.url);
+	if (!po.hasSecure()) {
+		console.log("No secure version:", po.p);
+		console.groupEnd();
+		return {};
+	}
+
+	var site = API['site.match']({site:po.o});
+
+	if (!site) {
+		console.log("No site found");
+		if (request.tabId != -1) {
+			chrome.tabs.get(request.tabId, function(tab) {
+				console.log("Incognito:", tab.incognito);
+				console.groupEnd();
+				if (!tab.incognito) {
+					doPotentialSite(po);
+				}
+			});
+		} else {
+			console.log("Not a tabbed request");
+			console.groupEnd();
+			window.setTimeout(function() {
+				doPotentialSite(po);
+			}, 0);
+		}
+	} else if (po.hasSecure()) {
+		if (site.status == 'secure') {
+			var surl = po.makeSecure();
+			console.log("Secure:", surl);
+			if (requests[rId][surl]) {
+				console.log("Loop detected");
+				console.groupEnd();
+				return {};
+			}
+			requests[rId][surl] = true;
+			console.log("Redirecting "+request.url+" to "+surl);
+			console.groupEnd();
+			return {redirectUrl: surl}
+		} else if (site.status == 'blacklist') {
+			console.log("Blacklist "+request.url);
+			console.groupEnd();
+		} else {
+			console.log("Status:", site.status);
+			console.groupEnd();
+		}
+	}
+	return {};
+}
+chrome.webRequest.onBeforeRequest.addListener(onBeforeRequest, {urls: ['<all_urls>'], /*types: ['main_frame']*/}, ["blocking"]);
+
+/*function onBeforeRedirect(details) {
+	if (!details) return; // on handlerBehaviorChanged() 
+	if (requests[details.requestId]) {
+		requests[details.requestId][details.url] = true;
+	}
+}
+chrome.webRequest.onBeforeRedirect.addListener(onBeforeRedirect, {urls: ['<all_urls>']});*/
+
+function onCompleted(details) {
+	if (!details) return; // on handlerBehaviorChanged() 
+	delete requests[details.requestId];
+}
+chrome.webRequest.onCompleted.addListener(onCompleted, {urls: ['<all_urls>']});
+chrome.webRequest.onErrorOccurred.addListener(onCompleted, {urls: ['<all_urls>']});
+
+/// Call this whenever our data changes
+function redirectChanged() {
+	chrome.webRequest.handlerBehaviorChanged(onBeforeRequest);
+}
+localConnect('*', redirectChanged);