//
// See https://wiki.mozilla.org/Extension_Manager:Bootstrapped_Extensions
// for details.
+"use strict";
-const NAME = "bootstrap";
const global = this;
-const Cc = Components.classes;
-const Ci = Components.interfaces;
-const Cu = Components.utils;
-const Cr = Components.results;
+var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components;
-function module(uri) {
- let obj = {};
- Cu.import(uri, obj);
- return obj;
-}
+function module(uri) Cu.import(uri, {});
+
+const DEBUG = true;
+
+__defineGetter__("BOOTSTRAP", function () "resource://" + moduleName + "/bootstrap.jsm");
-const { AddonManager } = module("resource://gre/modules/AddonManager.jsm");
-const { XPCOMUtils } = module("resource://gre/modules/XPCOMUtils.jsm");
-const { Services } = module("resource://gre/modules/Services.jsm");
+var { AddonManager } = module("resource://gre/modules/AddonManager.jsm");
+var { XPCOMUtils } = module("resource://gre/modules/XPCOMUtils.jsm");
+var { Services } = module("resource://gre/modules/Services.jsm");
const resourceProto = Services.io.getProtocolHandler("resource")
.QueryInterface(Ci.nsIResProtocolHandler);
const categoryManager = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
const manager = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
-const BOOTSTRAP_JSM = "resource://dactyl/bootstrap.jsm";
-
const BOOTSTRAP_CONTRACT = "@dactyl.googlecode.com/base/bootstrap";
-JSMLoader = JSMLoader || BOOTSTRAP_CONTRACT in Cc && Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader;
-
-var JSMLoader = BOOTSTRAP_CONTRACT in Components.classes &&
- Components.classes[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader;
-// Temporary migration code.
-if (!JSMLoader && "@mozilla.org/fuel/application;1" in Components.classes)
- JSMLoader = Components.classes["@mozilla.org/fuel/application;1"]
- .getService(Components.interfaces.extIApplication)
- .storage.get("dactyl.JSMLoader", null);
+var name = "dactyl";
function reportError(e) {
- dump("\ndactyl: bootstrap: " + e + "\n" + (e.stack || Error().stack) + "\n");
+ let stack = e.stack || Error().stack;
+ dump("\n" + name + ": bootstrap: " + e + "\n" + stack + "\n");
Cu.reportError(e);
+ Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService)
+ .logStringMessage(stack);
+}
+function debug(...args) {
+ if (DEBUG)
+ dump(name + ": " + args.join(", ") + "\n");
}
-function httpGet(url) {
+function httpGet(uri) {
let xmlhttp = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest);
xmlhttp.overrideMimeType("text/plain");
- xmlhttp.open("GET", url, false);
+ xmlhttp.open("GET", uri.spec || uri, false);
xmlhttp.send(null);
return xmlhttp;
}
+let moduleName;
let initialized = false;
let addon = null;
let addonData = null;
let basePath = null;
+let bootstrap;
+let bootstrap_jsm;
let categories = [];
let components = {};
let resources = [];
let getURI = null;
-function updateVersion() {
- try {
- function isDev(ver) /^hg|pre$/.test(ver);
- if (typeof require === "undefined" || addon === addonData)
- return;
+let JSMLoader = {
+ SANDBOX: Cu.nukeSandbox && false,
- require(global, "config");
- require(global, "prefs");
- config.lastVersion = localPrefs.get("lastVersion", null);
+ get addon() addon,
- localPrefs.set("lastVersion", addon.version);
+ currentModule: null,
- if (!config.lastVersion || isDev(config.lastVersion) != isDev(addon.version))
- addon.applyBackgroundUpdates = AddonManager[isDev(addon.version) ? "AUTOUPDATE_DISABLE" : "AUTOUPDATE_DEFAULT"];
- }
- catch (e) {
- reportError(e);
- }
-}
+ factories: [],
-function startup(data, reason) {
- dump("dactyl: bootstrap: startup " + reasonToString(reason) + "\n");
- basePath = data.installPath;
+ get name() name,
- if (!initialized) {
- initialized = true;
+ get module() moduleName,
- dump("dactyl: bootstrap: init" + " " + data.id + "\n");
+ globals: {},
+ modules: {},
- addonData = data;
- addon = data;
- AddonManager.getAddonByID(addon.id, function (a) {
- addon = a;
- updateVersion();
- });
+ times: {
+ all: 0,
+ add: function add(major, minor, delta) {
+ this.all += delta;
- if (basePath.isDirectory())
- getURI = function getURI(path) {
- let uri = Services.io.newFileURI(basePath);
- uri.path += path;
- return Services.io.newFileURI(uri.QueryInterface(Ci.nsIFileURL).file);
- };
+ this[major] = (this[major] || 0) + delta;
+ if (minor) {
+ minor = ":" + minor;
+ this[minor] = (this[minor] || 0) + delta;
+ this[major + minor] = (this[major + minor] || 0) + delta;
+ }
+ },
+ clear: function clear() {
+ for (let key in this)
+ if (typeof this[key] !== "number")
+ delete this[key];
+ }
+ },
+
+ getTarget: function getTarget(url) {
+ let uri = Services.io.newURI(url, null, null);
+ if (uri.schemeIs("resource"))
+ return resourceProto.resolveURI(uri);
+
+ let chan = Services.io.newChannelFromURI(uri);
+ try { chan.cancel(Cr.NS_BINDING_ABORTED); } catch (e) {}
+ return chan.name;
+ },
+
+ _atexit: [],
+
+ atexit: function atexit(arg, self) {
+ if (typeof arg !== "string")
+ this._atexit.push(arguments);
else
- getURI = function getURI(path)
- Services.io.newURI("jar:" + Services.io.newFileURI(basePath).spec + "!/" + path, null, null);
+ for each (let [fn, self] in this._atexit)
+ try {
+ fn.call(self, arg);
+ }
+ catch (e) {
+ reportError(e);
+ }
+ },
- try {
- init();
- }
- catch (e) {
- reportError(e);
+ _load: function _load(name, target) {
+ let urls = [name];
+ if (name.indexOf(":") === -1)
+ urls = this.config["module-paths"].map(function (path) path + name + ".jsm");
+
+ for each (let url in urls)
+ try {
+ var uri = this.getTarget(url);
+ if (uri in this.globals)
+ return this.modules[name] = this.globals[uri];
+
+ this.globals[uri] = this.modules[name];
+ bootstrap_jsm.loadSubScript(url, this.modules[name]);
+ return;
+ }
+ catch (e) {
+ debug("Loading " + name + ": " + e);
+ delete this.globals[uri];
+
+ if (typeof e != "string")
+ throw e;
+ }
+
+ throw Error("No such module: " + name);
+ },
+
+ load: function load(name, target) {
+ if (!this.modules.hasOwnProperty(name)) {
+ this.modules[name] = this.modules.base ? bootstrap.create(this.modules.base)
+ : bootstrap.import({ JSMLoader: this, module: global.module });
+
+ let currentModule = this.currentModule;
+ this.currentModule = this.modules[name];
+
+ try {
+ this._load(name, this.modules[name]);
+ }
+ catch (e) {
+ delete this.modules[name];
+ reportError(e);
+ throw e;
+ }
+ finally {
+ this.currentModule = currentModule;
+ }
}
- }
-}
-function FactoryProxy(url, classID) {
- this.url = url;
- this.classID = Components.ID(classID);
-}
-FactoryProxy.prototype = {
- QueryInterface: XPCOMUtils.generateQI(Ci.nsIFactory),
- register: function () {
- dump("dactyl: bootstrap: register: " + this.classID + " " + this.contractID + "\n");
+ let module = this.modules[name];
+ if (target)
+ for each (let symbol in module.EXPORTED_SYMBOLS)
+ target[symbol] = module[symbol];
- JSMLoader.registerFactory(this);
+ return module;
},
- get module() {
- dump("dactyl: bootstrap: create module: " + this.contractID + "\n");
- Object.defineProperty(this, "module", { value: {}, enumerable: true });
- JSMLoader.load(this.url, this.module);
- return this.module;
+ // Cuts down on stupid, fscking url mangling.
+ get loadSubScript() bootstrap_jsm.loadSubScript,
+
+ cleanup: function unregister() {
+ for each (let factory in this.factories.splice(0))
+ manager.unregisterFactory(factory.classID, factory);
},
- createInstance: function (iids) {
- return let (factory = this.module.NSGetFactory(this.classID))
- factory.createInstance.apply(factory, arguments);
+
+ Factory: function Factory(class_) ({
+ __proto__: class_.prototype,
+
+ createInstance: function (outer, iid) {
+ try {
+ if (outer != null)
+ throw Cr.NS_ERROR_NO_AGGREGATION;
+ if (!class_.instance)
+ class_.instance = new class_();
+ return class_.instance.QueryInterface(iid);
+ }
+ catch (e) {
+ Cu.reportError(e);
+ throw e;
+ }
+ }
+ }),
+
+ registerFactory: function registerFactory(factory) {
+ manager.registerFactory(factory.classID,
+ String(factory.classID),
+ factory.contractID,
+ factory);
+ this.factories.push(factory);
}
-}
+};
function init() {
- dump("dactyl: bootstrap: init\n");
+ debug("bootstrap: init");
let manifestURI = getURI("chrome.manifest");
- let manifest = httpGet(manifestURI.spec)
+ let manifest = httpGet(manifestURI)
.responseText
+ .replace(/#(resource)#/g, "$1")
.replace(/^\s*|\s*$|#.*/g, "")
.replace(/^\s*\n/gm, "");
- let suffix = "-";
- let chars = "0123456789abcdefghijklmnopqrstuv";
- for (let n = Date.now(); n; n = Math.round(n / chars.length))
- suffix += chars[n % chars.length];
-
for each (let line in manifest.split("\n")) {
let fields = line.split(/\s+/);
switch(fields[0]) {
break;
case "resource":
- var hardSuffix = /^[^\/]*/.exec(fields[2])[0];
-
- resources.push(fields[1], fields[1] + suffix);
+ moduleName = moduleName || fields[1];
+ resources.push(fields[1]);
resourceProto.setSubstitution(fields[1], getURI(fields[2]));
- resourceProto.setSubstitution(fields[1] + suffix, getURI(fields[2]));
}
}
+ JSMLoader.config = JSON.parse(httpGet("resource://dactyl-local/config.json").responseText);
+
+ bootstrap_jsm = module(BOOTSTRAP);
+ if (!JSMLoader.SANDBOX)
+ bootstrap = bootstrap_jsm;
+ else {
+ bootstrap = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance(),
+ { sandboxName: BOOTSTRAP });
+ Services.scriptloader.loadSubScript(BOOTSTRAP, bootstrap);
+ }
+ bootstrap.require = JSMLoader.load("base").require;
+
// Flush the cache if necessary, just to be paranoid
let pref = "extensions.dactyl.cacheFlushCheck";
- let val = addon.version + "-" + hardSuffix;
+ let val = addon.version;
if (!Services.prefs.prefHasUserValue(pref) || Services.prefs.getCharPref(pref) != val) {
+ var cacheFlush = true;
Services.obs.notifyObservers(null, "startupcache-invalidate", "");
Services.prefs.setCharPref(pref, val);
}
try {
- module("resource://dactyl-content/disable-acr.jsm").init(addon.id);
+ //JSMLoader.load("disable-acr").init(addon.id);
}
catch (e) {
reportError(e);
}
- if (JSMLoader) {
- if (Cu.unload) {
- Cu.unload(BOOTSTRAP_JSM);
- for (let [name] in Iterator(JSMLoader.globals))
- Cu.unload(~name.indexOf(":") ? name : "resource://dactyl" + JSMLoader.suffix + "/" + name);
- }
- else if (JSMLoader.bump != 5) // Temporary hack
- Services.scriptloader.loadSubScript("resource://dactyl" + suffix + "/bootstrap.jsm",
- Cu.import(BOOTSTRAP_JSM, global));
- }
+ Services.obs.notifyObservers(null, "dactyl-rehash", null);
- if (!JSMLoader || JSMLoader.bump !== 5 || Cu.unload)
- Cu.import(BOOTSTRAP_JSM, global);
+ JSMLoader.bootstrap = global;
- JSMLoader.bootstrap = this;
+ JSMLoader.load("config", global);
+ JSMLoader.load("main", global);
- JSMLoader.load(BOOTSTRAP_JSM, global);
+ JSMLoader.cacheFlush = cacheFlush;
+ JSMLoader.load("base", global);
- JSMLoader.init(suffix);
- JSMLoader.load("base.jsm", global);
+ if (!(BOOTSTRAP_CONTRACT in Cc)) {
+ // Use Sandbox to prevent closures over this scope
+ let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance());
+ let factory = Cu.evalInSandbox("({ createInstance: function () this })", sandbox);
- if (!(BOOTSTRAP_CONTRACT in Cc))
- manager.registerFactory(Components.ID("{f541c8b0-fe26-4621-a30b-e77d21721fb5}"),
- String("{f541c8b0-fe26-4621-a30b-e77d21721fb5}"),
- BOOTSTRAP_CONTRACT, {
- QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory]),
- instance: {
- QueryInterface: XPCOMUtils.generateQI([]),
- contractID: BOOTSTRAP_CONTRACT,
- wrappedJSObject: {}
- },
- createInstance: function () this.instance
- });
+ factory.classID = Components.ID("{f541c8b0-fe26-4621-a30b-e77d21721fb5}");
+ factory.contractID = BOOTSTRAP_CONTRACT;
+ factory.QueryInterface = XPCOMUtils.generateQI([Ci.nsIFactory]);
+ factory.wrappedJSObject = factory;
+
+ manager.registerFactory(factory.classID, String(factory.classID),
+ BOOTSTRAP_CONTRACT, factory);
+ }
Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader = !Cu.unload && JSMLoader;
for each (let component in components)
component.register();
- Services.obs.notifyObservers(null, "dactyl-rehash", null);
updateVersion();
- require(global, "overlay");
+
+ if (addon !== addonData)
+ require("main", global);
+}
+
+/**
+ * Performs necessary migrations after a version change.
+ */
+function updateVersion() {
+ function isDev(ver) /^hg|pre$/.test(ver);
+ try {
+ if (typeof require === "undefined" || addon === addonData)
+ return;
+
+ JSMLoader.load("prefs", global);
+ config.lastVersion = localPrefs.get("lastVersion", null);
+
+ localPrefs.set("lastVersion", addon.version);
+
+ // We're switching from a nightly version to a stable or
+ // semi-stable version or vice versa.
+ //
+ // Disable automatic updates when switching to nightlies,
+ // restore the default action when switching to stable.
+ if (!config.lastVersion || isDev(config.lastVersion) != isDev(addon.version))
+ addon.applyBackgroundUpdates = AddonManager[isDev(addon.version) ? "AUTOUPDATE_DISABLE" : "AUTOUPDATE_DEFAULT"];
+ }
+ catch (e) {
+ reportError(e);
+ }
+}
+
+function startup(data, reason) {
+ debug("bootstrap: startup " + reasonToString(reason));
+ basePath = data.installPath;
+
+ if (!initialized) {
+ initialized = true;
+
+ debug("bootstrap: init " + data.id);
+
+ addonData = data;
+ addon = data;
+ name = data.id.replace(/@.*/, "");
+ AddonManager.getAddonByID(addon.id, function (a) {
+ addon = a;
+
+ updateVersion();
+ if (typeof require !== "undefined")
+ require("main", global);
+ });
+
+ if (basePath.isDirectory())
+ getURI = function getURI(path) {
+ let uri = Services.io.newFileURI(basePath);
+ uri.path += path;
+ return Services.io.newFileURI(uri.QueryInterface(Ci.nsIFileURL).file);
+ };
+ else
+ getURI = function getURI(path)
+ Services.io.newURI("jar:" + Services.io.newFileURI(basePath).spec.replace(/!/g, "%21") + "!" +
+ "/" + path, null, null);
+
+ try {
+ init();
+ }
+ catch (e) {
+ reportError(e);
+ }
+ }
+}
+
+/**
+ * An XPCOM class factory proxy. Loads the JavaScript module at *url*
+ * when an instance is to be created and calls its NSGetFactory method
+ * to obtain the actual factory.
+ *
+ * @param {string} url The URL of the module housing the real factory.
+ * @param {string} classID The CID of the class this factory represents.
+ */
+function FactoryProxy(url, classID) {
+ this.url = url;
+ this.classID = Components.ID(classID);
+}
+FactoryProxy.prototype = {
+ QueryInterface: XPCOMUtils.generateQI(Ci.nsIFactory),
+ register: function () {
+ debug("bootstrap: register: " + this.classID + " " + this.contractID);
+
+ JSMLoader.registerFactory(this);
+ },
+ get module() {
+ debug("bootstrap: create module: " + this.contractID);
+
+ Object.defineProperty(this, "module", { value: {}, enumerable: true });
+ JSMLoader.load(this.url, this.module);
+ return this.module;
+ },
+ createInstance: function (iids) {
+ return let (factory = this.module.NSGetFactory(this.classID))
+ factory.createInstance.apply(factory, arguments);
+ }
}
function shutdown(data, reason) {
- dump("dactyl: bootstrap: shutdown " + reasonToString(reason) + "\n");
+ let strReason = reasonToString(reason);
+ debug("bootstrap: shutdown " + strReason);
+
if (reason != APP_SHUTDOWN) {
try {
- module("resource://dactyl-content/disable-acr.jsm").cleanup();
+ //JSMLoader.load("disable-acr").cleanup(addon.id);
}
catch (e) {
reportError(e);
if (~[ADDON_UPGRADE, ADDON_DOWNGRADE, ADDON_UNINSTALL].indexOf(reason))
Services.obs.notifyObservers(null, "dactyl-purge", null);
- Services.obs.notifyObservers(null, "dactyl-cleanup", reasonToString(reason));
+ Services.obs.notifyObservers(null, "dactyl-cleanup", strReason);
Services.obs.notifyObservers(null, "dactyl-cleanup-modules", reasonToString(reason));
- JSMLoader.purge();
+ JSMLoader.atexit(strReason);
+ JSMLoader.cleanup(strReason);
+
+ if (JSMLoader.SANDBOX)
+ Cu.nukeSandbox(bootstrap);
+ bootstrap_jsm.require = null;
+ Cu.unload(BOOTSTRAP);
+ bootstrap = null;
+ bootstrap_jsm = null;
+
for each (let [category, entry] in categories)
categoryManager.deleteCategoryEntry(category, entry, false);
for each (let resource in resources)
}
}
+function uninstall(data, reason) {
+ debug("bootstrap: uninstall " + reasonToString(reason));
+ if (reason == ADDON_UNINSTALL) {
+ Services.prefs.deleteBranch("extensions.dactyl.");
+
+ if (BOOTSTRAP_CONTRACT in Cc) {
+ let service = Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject;
+ manager.unregisterFactory(service.classID, service);
+ }
+ }
+}
+
function reasonToString(reason) {
for each (let name in ["disable", "downgrade", "enable",
"install", "shutdown", "startup",
return name;
}
-function install(data, reason) { dump("dactyl: bootstrap: install " + reasonToString(reason) + "\n"); }
-function uninstall(data, reason) { dump("dactyl: bootstrap: uninstall " + reasonToString(reason) + "\n"); }
+function install(data, reason) { debug("bootstrap: install " + reasonToString(reason)); }
// vim: set fdm=marker sw=4 ts=4 et: