Major changes this release include an updated data format, refactoring the content scripts to omit references to unsafeWindow, and refactoring storage. Due to storage changes, previously stored connections will be wiped out with this upgrade. We expect users' connections graph to be restored to their normal state in a few days, since quota limits restrict the amount of data stored anyway. For a complete list of changes, please visit our github repository.
First-time contributors for this release include Francois Marier, Spyros Livathinos, and Andrew William-Smith. We are very fortunate to have such wonderful contributors in our community.
logo in the Add-on bar.
Lightbeam starts recording connections as soon as it's installed. If you open it now, you'll see a blank screen because nothing's been recorded yet.
To start visualizing your online interactions, open a new tab, navigate to a site, and then check back to the Lightbeam tab to see how your connections graph appears.
You have one or more private browsing windows open.
" + "Connections made in private browsing windows will be visualized in Lightbeam but that data is not stored.
" + "Information gathered in private browsing mode will be deleted whenever Lightbeam is restarted, and is not collected at all when Lightbeam is not open..
", "imageUrl": "image/lightbeam_popup_privacy.png" }, function (confirmed) {} ); } function confirmBlockSitesDialog(callback) { dialog({ "name": dialogNames.blockSites, "title": "Block Sites", "message": "Warning:
" + "Blocking sites will prevent any and all content from being loaded from selected domains, for example: [example.com, example.net] and all of their subdomains [mail.example.com, news.example.net etc.].
" + "This can prevent some sites from working and degrade your internet experience. Please use this feature carefully.
", "imageUrl": "image/lightbeam_popup_blocked.png" }, callback ); } function confirmHideSitesDialog(callback) { dialog({ "name": dialogNames.hideSites, "dnsPrompt": true, "title": "Hide Sites", "message": "These sites will not be shown in Lightbeam visualizations, including List View, unless you specifically toggle them back on with the Show Hidden Sites button.
" + "You can use this to ignore trusted sites from the data.
", "imageUrl": "image/lightbeam_popup_hidden.png" }, callback ); } function confirmResetDataDialog(callback) { dialog({ "name": dialogNames.resetData, "title": "Reset Data", "message": "Pressing OK will delete all Lightbeam information including connection history, user preferences, block sites list etc.
" + "Your browser will be returned to the state of a fresh install of Lightbeam.
", "imageUrl": "image/lightbeam_popup_warningreset.png" }, callback); } function confirmTrackingProtectionDialog(callback) { dialog({ "name": dialogNames.trackingProtection, "title": "Tracking Protection", "message": "Warning:
" + "Enabling this experimental feature will block elements that track your online behavior.
" + "This can prevent some sites from working and degrade your internet experience. Please use this feature carefully.
" + "Please report any problems you find.
" + '', "imageUrl": "image/lightbeam_popup_blocked.png" }, callback); } resources/lightbeam/data/d3/ 0000755 0000000 0000000 00000000000 02263405520 014737 5 ustar root root resources/lightbeam/data/content-script.js 0000644 0000000 0000000 00000003275 12460353406 017757 0 ustar root root /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ (function (global) { // This is the e10s/message passing content script that ties the workers to the // addon. It can see most of the addon, the window is either not visible or not // mutable so we use unsafeWindow below. This handles the post message // connections and does a little UI work on the side. self.port.on('connection', function (connection) { global.allConnections.push(connection); global.aggregate.emit('connection', connection); }); self.port.on('passStoredConnections', function (connections) { global.allConnections = connections; global.aggregate.emit('load', global.allConnections); }); self.port.on('update-blocklist', function (domain) { global.aggregate.emit('update-blocklist', domain); }); self.port.on('update-blocklist-all', function (domains) { global.aggregate.emit('update-blocklist-all', domains); }); self.port.on('init', function () { console.debug('content-script::init()'); global.aggregate.emit('load', global.allConnections); }); self.port.on("updateUIFromMetadata", function (metadata) { console.debug("Got add-on metadata", metadata); global.aggregate.emit("updateUIFromMetadata", metadata); }); self.port.on("updateUIFromBrowserPrefs", function (browserPrefs) { console.debug("Got set browser prefs", browserPrefs); global.aggregate.emit("updateUIFromBrowserPrefs", browserPrefs); }); self.port.on("updateUIFromPrefs", function (prefs) { console.debug("Got set prefs", prefs); global.aggregate.emit("updateUIFromPrefs", prefs); }); })(this); resources/lightbeam/data/aggregate.js 0000644 0000000 0000000 00000040553 12462544054 016734 0 ustar root root /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // Graph Visualization // Visualization of tracking data interconnections (function (global) { "use strict"; // An emitter that lists nodes and edges so we can build the data structure // used by all 3 visualizers. var aggregate = new Emitter(); global.aggregate = aggregate; global.filteredAggregate = { nodes: [], edges: [] }; // The name of the current filter (daily, weekly, recent, last10sites) aggregate.currentFilter = "daily"; aggregate.trackerCount = 0; aggregate.siteCount = 0; // d3 has functionality to build graphs out of lists of nodes and edges. aggregate.nodes = []; aggregate.edges = []; aggregate.recentSites = []; aggregate.initialized = false; aggregate.nodemap = {}; aggregate.edgemap = {}; function resetData() { console.debug('aggregate::resetData'); aggregate.getBlockedDomains().forEach(function (domain) { console.debug("deleting", domain); delete userSettings[domain]; }); aggregate.nodemap = {}; aggregate.edgemap = {}; aggregate.nodes = []; aggregate.edges = []; aggregate.trackerCount = 0; aggregate.siteCount = 0; aggregate.recentSites = []; global.currentVisualization.emit('reset'); updateStatsBar(); } aggregate.on('reset', resetData); aggregate.getBlockedDomains = function () { return Object.keys(userSettings).filter(function (domain) { return userSettings[domain] == 'block'; }); }; aggregate.getAllNodes = function () { var blockedDomains = aggregate.getBlockedDomains(); console.debug("getAllNodes", JSON.stringify(blockedDomains)); return aggregate.nodes.concat(blockedDomains.map(function (domain) { return { site: domain, nodeType: 'blocked', name: domain }; })); }; aggregate.getConnectionCount = function (node) { if (node.nodeType === 'blocked') return 0; let connections = Object.keys(aggregate.nodeForKey(node.name)).length; return connections - 1 > 0 ? connections - 1 : 0; }; aggregate.nodeForKey = function (key) { var result = {}; var linkedNodes = []; if (aggregate.nodemap[key]) { linkedNodes = aggregate.nodemap[key].linkedFrom.concat(aggregate.nodemap[key].linkedTo); result[key] = aggregate.nodemap[key]; } else { linkedNodes = []; result[key] = {}; } linkedNodes.forEach(function (nodeName) { var node = aggregate.nodemap[nodeName]; var temp = {}; for (var p in node) { if (node.hasOwnProperty(p) && !(p == "linkedFrom" || p == "linkedTo")) { temp[p] = node[p]; } } result[nodeName] = temp; }); return result; }; aggregate.connectionAsObject = function (conn) { if (Array.isArray(conn)) { return { source: conn[SOURCE], target: conn[TARGET], timestamp: new Date(conn[TIMESTAMP]), contentType: conn[CONTENT_TYPE], cookie: conn[COOKIE], sourceVisited: conn[SOURCE_VISITED], secure: conn[SECURE], sourcePathDepth: conn[SOURCE_PATH_DEPTH], sourceQueryDepth: conn[SOURCE_QUERY_DEPTH], sourceSub: conn[SOURCE_SUB], targetSub: conn[TARGET_SUB], method: conn[METHOD], status: conn[STATUS], cacheable: conn[CACHEABLE] }; } return conn; }; // Pass the list of connections to build the graph structure to pass to d3 for // visualizations. function onLoad(connections) { var startTime = Date.now(); console.debug("aggregate::onLoad", connections.length, "connections", aggregate.currentFilter); connections.forEach(onConnection); aggregate.initialized = true; filteredAggregate = aggregate.filters[aggregate.currentFilter](); // Tell the visualization that we're ready. if (global.currentVisualization) { global.currentVisualization.emit('init'); } updateStatsBar(); console.debug('aggregate::onLoad end, took %s ms', Date.now() - startTime); } function updateUIFromMetadata(metadata) { console.debug("in aggregate metadata"); global.updateUIFromMetadata(metadata); } function updateUIFromBrowserPrefs(browserPrefs) { console.debug("in aggregate browser prefs"); global.updateUIFromBrowserPrefs(browserPrefs); } function updateUIFromPrefs(prefs) { console.debug("in aggregate prefs"); global.updateUIFromPrefs(prefs); } aggregate.on('load', onLoad); aggregate.on("updateUIFromMetadata", updateUIFromMetadata); aggregate.on("updateUIFromBrowserPrefs", updateUIFromBrowserPrefs); aggregate.on("updateUIFromPrefs", updateUIFromPrefs); // Constants for indexes of properties in array format const SOURCE = 0; const TARGET = 1; const TIMESTAMP = 2; const CONTENT_TYPE = 3; const COOKIE = 4; const SOURCE_VISITED = 5; const SECURE = 6; const SOURCE_PATH_DEPTH = 7; const SOURCE_QUERY_DEPTH = 8; const SOURCE_SUB = 9; const TARGET_SUB = 10; const METHOD = 11; const STATUS = 12; const CACHEABLE = 13; // Check that recent sites include the domain. This is another potential source // of false positives. aggregate.isDomainVisited = function isDomainVisited(domain) { return aggregate.recentSites.length && (aggregate.recentSites.indexOf(domain) > -1); }; function onConnection(conn) { // A connection has the following keys: // source (url), target (url), timestamp (int), contentType (str), cookie (bool), sourceVisited (bool), secure(bool), sourcePathDepth (int), sourceQueryDepth(int) // We want to shape the collection of connections that represent points in time into // aggregate data for graphing. Each connection has two endpoints represented by GraphNode objects // and one edge represented by a GraphEdge object, but we want to re-use these when connections // map to the same endpoints or edges. var connection = aggregate.connectionAsObject(conn); var sourcenode, targetnode, edge, nodelist, updated = false; // Maintain the list of sites visited in dated order // console.log('check for recent sites: %s: %s', connection.source, connection.sourceVisited); if (connection.sourceVisited) { // console.log('source visited: %s -> %s', connection.source, connection.target); var site = connection.target; var siteIdx = aggregate.recentSites.indexOf(site); if (aggregate.recentSites.length && siteIdx === (aggregate.recentSites.length - 1)) { // most recent site is already at the end of the recentSites list, do nothing } else { if (siteIdx > -1) { // if site is already in list (but not last), remove it aggregate.recentSites.splice(siteIdx, 1); } aggregate.recentSites.push(site); // push site on end of list if it is not there updated = true; } } else { // console.log('source not visited: %s -> %s', connection.source, connection.target); } // Retrieve the source node and update, or create it if not found if (aggregate.nodemap[connection.source]) { sourcenode = aggregate.nodemap[connection.source]; if (connection.sourceVisited && sourcenode.nodeType == "thirdparty") { // the previously "thirdparty" site has now become a "visited" site // +1 on visited sites counter and -1 on trackers counter aggregate.siteCount++; aggregate.trackerCount--; } sourcenode.update(connection, true); } else { sourcenode = new GraphNode(connection, true); aggregate.nodemap[connection.source] = sourcenode; aggregate.nodes.push(sourcenode); if (connection.sourceVisited) { aggregate.siteCount++; } else { aggregate.trackerCount++; } // console.log('new source: %s, now %s nodes', sourcenode.name, aggregate.nodes.length); updated = true; } // Retrieve the target node and update, or create it if not found if (aggregate.nodemap[connection.target]) { targetnode = aggregate.nodemap[connection.target]; targetnode.update(connection, false); } else { targetnode = new GraphNode(connection, false); aggregate.nodemap[connection.target] = targetnode; aggregate.nodes.push(targetnode); // all nodes if (connection.sourceVisited) { aggregate.siteCount++; // Can this ever be true? } else { aggregate.trackerCount++; } // console.log('new target: %s, now %s nodes', targetnode.name, aggregate.nodes.length); updated = true; } // Create edge objects. Could probably do this lazily just for the graph view if (aggregate.edgemap[connection.source + '->' + connection.target]) { edge = aggregate.edgemap[connection.source + '->' + connection.target]; edge.update(connection); } else { edge = new GraphEdge(sourcenode, targetnode, connection); aggregate.edgemap[edge.name] = edge; aggregate.edges.push(edge); // updated = true; } if (updated) { aggregate.update(); } updateStatsBar(); } aggregate.on('connection', onConnection); function onBlocklistUpdate({ domain, flag }) { if (flag === true) { userSettings[domain] = 'block'; } else if (userSettings[domain] == 'block') { delete userSettings[domain]; } } aggregate.on('update-blocklist', onBlocklistUpdate); // Read the blocklist to memory function onBlocklistUpdateAll(domains) { (domains || []).forEach(onBlocklistUpdate); } aggregate.on('update-blocklist-all', onBlocklistUpdateAll); // Used only by the graph view. function GraphEdge(source, target, connection) { var name = source.name + '->' + target.name; if (aggregate.edgemap[name]) { return aggregate.edgemap[name]; } this.source = source; this.target = target; this.name = name; if (connection) { this.cookieCount = connection.cookie ? 1 : 0; } return this; // console.log('edge: %s', this.name); } GraphEdge.prototype.lastAccess = function () { return (this.source.lastAccess > this.target.lastAccess) ? this.source.lastAccess : this.target.lastAccess; }; GraphEdge.prototype.firstAccess = function () { return (this.source.firstAccess < this.target.firstAccess) ? this.source.firstAccess : this.target.firstAccess; }; GraphEdge.prototype.update = function (connection) { this.cookieCount = connection.cookie ? this.cookieCount + 1 : this.cookieCount; }; // A graph node represents one end of a connection, either a target or a source // Where a connection is a point in time with a timestamp, a graph node has a time range // represented by firstAccess and lastAccess. Where a connection has a contentType, a node // has an array of content types. Booleans in graph nodes become boolean pairs in graph nodes // (for instance, some connections may have cookies and some may not, which would result in both // cookie and notCookie being true). We set an initial position randomly to keep the force graph // from exploding. // function GraphNode(connection, isSource) { this.firstAccess = this.lastAccess = connection.timestamp; this.linkedFrom = []; this.linkedTo = []; this.contentTypes = []; this.subdomain = []; this.method = []; this.status = []; this.visitedCount = 0; this.secureCount = 0; this.cookieCount = 0; this.howMany = 0; if (connection) { this.update(connection, isSource); } // FIXME: Get the width and height from the add-on somehow var width = 1000; var height = 1000; // Set defaults for graph this.x = this.px = (Math.random() - 0.5) * 800 + width / 2; this.y = this.py = (Math.random() - 0.5) * 800 + height / 2; this.weight = 0; } GraphNode.prototype.update = function (connection, isSource) { if (!this.name) { this.name = isSource ? connection.source : connection.target; // console.log('node: %s', this.name); } if (connection.timestamp > this.lastAccess) { this.lastAccess = connection.timestamp; } if (connection.timestamp < this.firstAccess) { this.firstAccess = connection.timestamp; } if (isSource && (this.linkedTo.indexOf(connection.target) < 0)) { this.linkedTo.push(connection.target); } if ((!isSource) && (this.linkedFrom.indexOf(connection.source) < 0)) { this.linkedFrom.push(connection.source); } if (this.contentTypes.indexOf(connection.contentType) < 0) { this.contentTypes.push(connection.contentType); } if (connection.sourceVisited) { this.visitedCount++; } if (this.subdomain.indexOf(connection.sourceSub) < 0) { this.subdomain.push(connection.sourceSub); } if (connection.cookie) { this.cookieCount++; } if (connection.secure) { this.secureCount++; } if (this.method.indexOf(connection.method) < 0) { this.method.push(connection.method); } if (this.status.indexOf(connection.status) < 0) { this.status.push(connection.status); } this.howMany++; if (this.visitedCount / this.howMany == 1) { this.nodeType = 'site'; } else if (this.visitedCount / this.howMany === 0) { this.nodeType = 'thirdparty'; } else { this.nodeType = 'both'; } return this; }; // Filtering function sitesSortedByDate() { return aggregate.recentSites.map(function (sitename) { return aggregate.nodemap[sitename]; }); } aggregate.sitesSortedByDate = sitesSortedByDate; function aggregateFromNodes(nodes) { var localmap = {}; var edgemap = {}; nodes.forEach(function (node) { localmap[node.name] = node; node.linkedFrom.forEach(function (nodename) { var linkedNode = aggregate.nodemap[nodename]; var edge = new GraphEdge(node, linkedNode); edgemap[edge.name] = edge; localmap[nodename] = linkedNode; }); node.linkedTo.forEach(function (nodename) { var linkedNode = aggregate.nodemap[nodename]; var edge = new GraphEdge(node, linkedNode); edgemap[edge.name] = edge; localmap[nodename] = linkedNode; }); }); return { nodes: Object.keys(localmap).map(function (name) { return localmap[name]; }), edges: Object.keys(edgemap).map(function (name) { return edgemap[name]; }) }; } // filters aggregate.filters = { daily: function daily() { var now = Date.now(); var then = now - (24 * 60 * 60 * 1000); var sortedNodes = sitesSortedByDate(); // find index where we go beyond date var i; for (i = sortedNodes.length - 1; i > -1; i--) { if (sortedNodes[i].lastAccess.valueOf() < then) { break; } } // i is always 1 too low at the point i++; // put it back var filteredNodes = sortedNodes.slice(i); // Done filtering return aggregateFromNodes(filteredNodes); }, weekly: function weekly() { var now = Date.now(); var then = now - (7 * 24 * 60 * 60 * 1000); var sortedNodes = sitesSortedByDate(); // find index where we go beyond date var i; for (i = sortedNodes.length - 1; i > -1; i--) { if (sortedNodes[i].lastAccess < then) { break; } } i++; // we decrement too far, put it back var filteredNodes = sortedNodes.slice(i); // console.log('weekly filter after: %s', filteredNodes.length); return aggregateFromNodes(filteredNodes); }, last10sites: function last10sites() { var sortedNodes = sitesSortedByDate(); var filteredNodes = sortedNodes.slice(-10); return aggregateFromNodes(filteredNodes); }, recent: function recent() { var sortedNodes = sitesSortedByDate(); var filteredNodes = sortedNodes.slice(-1); return aggregateFromNodes(filteredNodes); } }; function switchFilter(name) { if (aggregate.currentFilter == name) { return; } aggregate.currentFilter = name; global.self.port.emit("prefChanged", { defaultFilter: name }); aggregate.update(); } aggregate.switchFilter = switchFilter; // Underscore debounce function // // Returns a function, that, as long as it continues to be invoked, will not // be triggered. The function will be called after it stops being called for // N milliseconds. If `immediate` is passed, trigger the function on the // leading edge, instead of the trailing. var debounce = function debounce(func, wait, immediate) { var timeout; return function () { var context = this, args = arguments; var later = function () { timeout = null; if (!immediate) func.apply(context, args); }; var callNow = immediate && !timeout; clearTimeout(timeout); timeout = setTimeout(later, wait); if (callNow) func.apply(context, args); }; }; aggregate.update = debounce(function update() { // FIXME: maybe not for list view if (global.currentVisualization && global.currentVisualization.name !== 'graph') { console.debug('do not update aggregate for view', currentVisualization.name); } if (aggregate.initialized) { global.filteredAggregate = aggregate.filters[aggregate.currentFilter](); aggregate.emit('update'); } updateStatsBar(); }); })(this); resources/lightbeam/data/OpenSans.css 0000644 0000000 0000000 00000001174 12435776034 016711 0 ustar root root /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ @font-face { font-family: 'Open Sans'; font-style: italic; font-weight: 400; src: url('font/OpenSans-LightItalic.ttf') format('truetype') } @font-face { font-family: 'Open Sans'; font-style: bold; font-weight: 700; src: url('font/OpenSans-Bold.ttf') format('truetype') } @font-face { font-family: 'Open Sans'; font-style: normal; font-weight: 400; src: url('font/OpenSans-Light.ttf') format('truetype') } resources/addon-sdk/ 0000755 0000000 0000000 00000000000 02263405520 013430 5 ustar root root resources/addon-sdk/lib/ 0000755 0000000 0000000 00000000000 02263405520 014176 5 ustar root root bootstrap.js 0000644 0000000 0000000 00000030747 12460336656 012155 0 ustar root root /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // @see http://mxr.mozilla.org/mozilla-central/source/js/src/xpconnect/loader/mozJSComponentLoader.cpp 'use strict'; // IMPORTANT: Avoid adding any initialization tasks here, if you need to do // something before add-on is loaded consider addon/runner module instead! const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu, results: Cr, manager: Cm } = Components; const ioService = Cc['@mozilla.org/network/io-service;1']. getService(Ci.nsIIOService); const resourceHandler = ioService.getProtocolHandler('resource'). QueryInterface(Ci.nsIResProtocolHandler); const systemPrincipal = CC('@mozilla.org/systemprincipal;1', 'nsIPrincipal')(); const scriptLoader = Cc['@mozilla.org/moz/jssubscript-loader;1']. getService(Ci.mozIJSSubScriptLoader); const prefService = Cc['@mozilla.org/preferences-service;1']. getService(Ci.nsIPrefService). QueryInterface(Ci.nsIPrefBranch); const appInfo = Cc["@mozilla.org/xre/app-info;1"]. getService(Ci.nsIXULAppInfo); const vc = Cc["@mozilla.org/xpcom/version-comparator;1"]. getService(Ci.nsIVersionComparator); const REASON = [ 'unknown', 'startup', 'shutdown', 'enable', 'disable', 'install', 'uninstall', 'upgrade', 'downgrade' ]; const bind = Function.call.bind(Function.bind); let loader = null; let unload = null; let cuddlefishSandbox = null; let nukeTimer = null; let resourceDomains = []; function setResourceSubstitution(domain, uri) { resourceDomains.push(domain); resourceHandler.setSubstitution(domain, uri); } // Utility function that synchronously reads local resource from the given // `uri` and returns content string. function readURI(uri) { let ioservice = Cc['@mozilla.org/network/io-service;1']. getService(Ci.nsIIOService); let channel = ioservice.newChannel(uri, 'UTF-8', null); let stream = channel.open(); let cstream = Cc['@mozilla.org/intl/converter-input-stream;1']. createInstance(Ci.nsIConverterInputStream); cstream.init(stream, 'UTF-8', 0, 0); let str = {}; let data = ''; let read = 0; do { read = cstream.readString(0xffffffff, str); data += str.value; } while (read != 0); cstream.close(); return data; } // We don't do anything on install & uninstall yet, but in a future // we should allow add-ons to cleanup after uninstall. function install(data, reason) {} function uninstall(data, reason) {} function startup(data, reasonCode) { try { let reason = REASON[reasonCode]; // URI for the root of the XPI file. // 'jar:' URI if the addon is packed, 'file:' URI otherwise. // (Used by l10n module in order to fetch `locale` folder) let rootURI = data.resourceURI.spec; // TODO: Maybe we should perform read harness-options.json asynchronously, // since we can't do anything until 'sessionstore-windows-restored' anyway. let options = JSON.parse(readURI(rootURI + './harness-options.json')); let id = options.jetpackID; let name = options.name; // Clean the metadata options.metadata[name]['permissions'] = options.metadata[name]['permissions'] || {}; // freeze the permissionss Object.freeze(options.metadata[name]['permissions']); // freeze the metadata Object.freeze(options.metadata[name]); // Register a new resource 'domain' for this addon which is mapping to // XPI's `resources` folder. // Generate the domain name by using jetpack ID, which is the extension ID // by stripping common characters that doesn't work as a domain name: let uuidRe = /^\{([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\}$/; let domain = id. toLowerCase(). replace(/@/g, '-at-'). replace(/\./g, '-dot-'). replace(uuidRe, '$1'); let prefixURI = 'resource://' + domain + '/'; let resourcesURI = ioService.newURI(rootURI + '/resources/', null, null); setResourceSubstitution(domain, resourcesURI); // Create path to URLs mapping supported by loader. let paths = { // Relative modules resolve to add-on package lib './': prefixURI + name + '/lib/', './tests/': prefixURI + name + '/tests/', '': 'resource://gre/modules/commonjs/' }; // Maps addon lib and tests ressource folders for each package paths = Object.keys(options.metadata).reduce(function(result, name) { result[name + '/'] = prefixURI + name + '/lib/' result[name + '/tests/'] = prefixURI + name + '/tests/' return result; }, paths); // We need to map tests folder when we run sdk tests whose package name // is stripped if (name == 'addon-sdk') paths['tests/'] = prefixURI + name + '/tests/'; let useBundledSDK = options['force-use-bundled-sdk']; if (!useBundledSDK) { try { useBundledSDK = prefService.getBoolPref("extensions.addon-sdk.useBundledSDK"); } catch (e) { // Pref doesn't exist, allow using Firefox shipped SDK } } // Starting with Firefox 21.0a1, we start using modules shipped into firefox // Still allow using modules from the xpi if the manifest tell us to do so. // And only try to look for sdk modules in xpi if the xpi actually ship them if (options['is-sdk-bundled'] && (vc.compare(appInfo.version, '21.0a1') < 0 || useBundledSDK)) { // Maps sdk module folders to their resource folder paths[''] = prefixURI + 'addon-sdk/lib/'; // test.js is usually found in root commonjs or SDK_ROOT/lib/ folder, // so that it isn't shipped in the xpi. Keep a copy of it in sdk/ folder // until we no longer support SDK modules in XPI: paths['test'] = prefixURI + 'addon-sdk/lib/sdk/test.js'; } // Retrieve list of module folder overloads based on preferences in order to // eventually used a local modules instead of files shipped into Firefox. let branch = prefService.getBranch('extensions.modules.' + id + '.path'); paths = branch.getChildList('', {}).reduce(function (result, name) { // Allows overloading of any sub folder by replacing . by / in pref name let path = name.substr(1).split('.').join('/'); // Only accept overloading folder by ensuring always ending with `/` if (path) path += '/'; let fileURI = branch.getCharPref(name); // On mobile, file URI has to end with a `/` otherwise, setSubstitution // takes the parent folder instead. if (fileURI[fileURI.length-1] !== '/') fileURI += '/'; // Maps the given file:// URI to a resource:// in order to avoid various // failure that happens with file:// URI and be close to production env let resourcesURI = ioService.newURI(fileURI, null, null); let resName = 'extensions.modules.' + domain + '.commonjs.path' + name; setResourceSubstitution(resName, resourcesURI); result[path] = 'resource://' + resName + '/'; return result; }, paths); // Make version 2 of the manifest let manifest = options.manifest; // Import `cuddlefish.js` module using a Sandbox and bootstrap loader. let cuddlefishPath = 'loader/cuddlefish.js'; let cuddlefishURI = 'resource://gre/modules/commonjs/sdk/' + cuddlefishPath; if (paths['sdk/']) { // sdk folder has been overloaded // (from pref, or cuddlefish is still in the xpi) cuddlefishURI = paths['sdk/'] + cuddlefishPath; } else if (paths['']) { // root modules folder has been overloaded cuddlefishURI = paths[''] + 'sdk/' + cuddlefishPath; } cuddlefishSandbox = loadSandbox(cuddlefishURI); let cuddlefish = cuddlefishSandbox.exports; // Normalize `options.mainPath` so that it looks like one that will come // in a new version of linker. let main = options.mainPath; unload = cuddlefish.unload; loader = cuddlefish.Loader({ paths: paths, // modules manifest. manifest: manifest, // Add-on ID used by different APIs as a unique identifier. id: id, // Add-on name. name: name, // Add-on version. version: options.metadata[name].version, // Add-on package descriptor. metadata: options.metadata[name], // Add-on load reason. loadReason: reason, prefixURI: prefixURI, // Add-on URI. rootURI: rootURI, // options used by system module. // File to write 'OK' or 'FAIL' (exit code emulation). resultFile: options.resultFile, // Arguments passed as --static-args staticArgs: options.staticArgs, // Add-on preferences branch name preferencesBranch: options.preferencesBranch, // Arguments related to test runner. modules: { '@test/options': { allTestModules: options.allTestModules, iterations: options.iterations, filter: options.filter, profileMemory: options.profileMemory, stopOnError: options.stopOnError, verbose: options.verbose, parseable: options.parseable, checkMemory: options.check_memory, } } }); let module = cuddlefish.Module('sdk/loader/cuddlefish', cuddlefishURI); let require = cuddlefish.Require(loader, module); require('sdk/addon/runner').startup(reason, { loader: loader, main: main, prefsURI: rootURI + 'defaults/preferences/prefs.js' }); } catch (error) { dump('Bootstrap error: ' + (error.message ? error.message : String(error)) + '\n' + (error.stack || error.fileName + ': ' + error.lineNumber) + '\n'); throw error; } }; function loadSandbox(uri) { let proto = { sandboxPrototype: { loadSandbox: loadSandbox, ChromeWorker: ChromeWorker } }; let sandbox = Cu.Sandbox(systemPrincipal, proto); // Create a fake commonjs environnement just to enable loading loader.js // correctly sandbox.exports = {}; sandbox.module = { uri: uri, exports: sandbox.exports }; sandbox.require = function (id) { if (id !== "chrome") throw new Error("Bootstrap sandbox `require` method isn't implemented."); return Object.freeze({ Cc: Cc, Ci: Ci, Cu: Cu, Cr: Cr, Cm: Cm, CC: bind(CC, Components), components: Components, ChromeWorker: ChromeWorker }); }; scriptLoader.loadSubScript(uri, sandbox, 'UTF-8'); return sandbox; } function unloadSandbox(sandbox) { if ("nukeSandbox" in Cu) Cu.nukeSandbox(sandbox); } function setTimeout(callback, delay) { let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); timer.initWithCallback({ notify: callback }, delay, Ci.nsITimer.TYPE_ONE_SHOT); return timer; } function shutdown(data, reasonCode) { let reason = REASON[reasonCode]; if (loader) { unload(loader, reason); unload = null; // Don't waste time cleaning up if the application is shutting down if (reason != "shutdown") { // Avoid leaking all modules when something goes wrong with one particular // module. Do not clean it up immediatly in order to allow executing some // actions on addon disabling. // We need to keep a reference to the timer, otherwise it is collected // and won't ever fire. nukeTimer = setTimeout(nukeModules, 1000); // Bug 944951 - bootstrap.js must remove the added resource: URIs on unload resourceDomains.forEach(domain => { resourceHandler.setSubstitution(domain, null); }) } } }; function nukeModules() { nukeTimer = null; // module objects store `exports` which comes from sandboxes // We should avoid keeping link to these object to avoid leaking sandboxes for (let key in loader.modules) { delete loader.modules[key]; } // Direct links to sandboxes should be removed too for (let key in loader.sandboxes) { let sandbox = loader.sandboxes[key]; delete loader.sandboxes[key]; // Bug 775067: From FF17 we can kill all CCW from a given sandbox unloadSandbox(sandbox); } loader = null; // both `toolkit/loader` and `system/xul-app` are loaded as JSM's via // `cuddlefish.js`, and needs to be unloaded to avoid memory leaks, when // the addon is unload. unloadSandbox(cuddlefishSandbox.loaderSandbox); unloadSandbox(cuddlefishSandbox.xulappSandbox); // Bug 764840: We need to unload cuddlefish otherwise it will stay alive // and keep a reference to this compartment. unloadSandbox(cuddlefishSandbox); cuddlefishSandbox = null; } locales.json 0000644 0000000 0000000 00000000020 02263405520 012057 0 ustar root root {"locales": []} locale/ 0000755 0000000 0000000 00000000000 02263405520 011011 5 ustar root root defaults/ 0000755 0000000 0000000 00000000000 12515147346 011373 5 ustar root root defaults/preferences/ 0000755 0000000 0000000 00000000000 12515147346 013674 5 ustar root root defaults/preferences/prefs.js 0000644 0000000 0000000 00000000225 12464015254 015343 0 ustar root root pref("extensions.jid1-F9UJ2thwoAm5gQ@jetpack.defaultVisualization", "graph"); pref("extensions.jid1-F9UJ2thwoAm5gQ@jetpack.defaultFilter", "daily"); options.xul 0000644 0000000 0000000 00000001743 12464015254 012011 0 ustar root root