# HG changeset patch # User Yoshiki Yazawa # Date 1228217461 -32400 # Node ID dada0ac40a8f7a7926a30ef3fd6c0304f32f182b initial import diff -r 000000000000 -r dada0ac40a8f LICENSE --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/LICENSE Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,6 @@ +All files in this extension are assumed to be licensed under the +tri-license (MPL/GPL/LGPL) unless otherwise specified. + +The MPL is available at http://www.mozilla.org/MPL/MPL-1.1.html + +The source code is available on request from dtownsend@oxymoronical.com diff -r 000000000000 -r dada0ac40a8f chrome.manifest --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/chrome.manifest Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,25 @@ +content nightly jar:chrome/nightly.jar!/content/ +skin nightly classic/1.0 jar:chrome/nightly.jar!/skin/ + +locale nightly en-US jar:chrome/nightly.jar!/locale/en-US/ + +resource nightly modules/ + +overlay chrome://mozapps/content/extensions/extensions.xul chrome://nightly/content/extensions/addons.xul +override chrome://nightly/content/platform.js chrome://nightly/content/winPlatform.js os=winnt + +style chrome://browser/content/browser.xul chrome://nightly/skin/browser.css +style chrome://messenger/content/messenger.xul chrome://nightly/skin/browser.css +style chrome://navigator/content/navigator.xul chrome://nightly/skin/browser.css +style chrome://calendar/content/calendar.xul chrome://nightly/skin/browser.css +style chrome://global/content/customizeToolbar.xul chrome://nightly/skin/browser.css + +overlay chrome://browser/content/browser.xul chrome://nightly/content/browserOverlay.xul application={ec8030f7-c20a-464f-9b0e-13a3a9e97384} + +overlay chrome://messenger/content/messenger.xul chrome://nightly/content/messengerOverlay.xul application={3550f703-e582-4d05-9a08-453d09bdfdc6} + +overlay chrome://calendar/content/calendar.xul chrome://nightly/content/calendarOverlay.xul application={718e30fb-e89b-41dd-9da7-e25a45638b28} + +overlay chrome://navigator/content/navigator.xul chrome://nightly/content/suiteOverlay.xul application={92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a} + +overlay chrome://songbird/content/xul/layoutBaseOverlay.xul chrome://nightly/content/songbirdOverlay.xul application=songbird@songbirdnest.com diff -r 000000000000 -r dada0ac40a8f chrome/nightly.jar Binary file chrome/nightly.jar has changed diff -r 000000000000 -r dada0ac40a8f components/nightly.xpt Binary file components/nightly.xpt has changed diff -r 000000000000 -r dada0ac40a8f components/nttAddonCompatibilityService.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/components/nttAddonCompatibilityService.js Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,506 @@ +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cr = Components.results; + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +const PREFIX_NS_EM = "http://www.mozilla.org/2004/em-rdf#"; +const PREFIX_ITEM_URI = "urn:mozilla:item:"; +const RDFURI_INSTALL_MANIFEST_ROOT = "urn:mozilla:install-manifest"; +const FILE_INSTALL_MANIFEST = "install.rdf"; +const TOOLKIT_ID = "toolkit@mozilla.org" + +var gEM = null; +var gRDF = null; +var gApp = null; +var gVC = null; +var gCheckCompatibility = true; +var gCheckUpdateSecurity = true; +var gPrefs = null; + +function EM_NS(property) { + return PREFIX_NS_EM + property; +} + +function EM_R(property) { + return gRDF.GetResource(EM_NS(property)); +} + +function getRDFProperty(ds, source, property) { + var value = ds.GetTarget(source, EM_R(property), true); + if (value && value instanceof Ci.nsIRDFLiteral) + return value.Value; + return null; +} + +function removeRDFProperty(ds, source, property) { + var arc = EM_R(property); + var targets = ds.GetTargets(source, arc, true); + while (targets.hasMoreElements()) + ds.Unassert(source, arc, targets.getNext()); +} + +function extractXPI(xpi) { + // XXX For 1.9 final we can switch to just extracting/compressing install.rdf + var zipReader = Cc["@mozilla.org/libjar/zip-reader;1"]. + createInstance(Ci.nsIZipReader); + zipReader.open(xpi); + if (!zipReader.hasEntry(FILE_INSTALL_MANIFEST)) { + zipReader.close(); + return null; + } + var dirs = Cc["@mozilla.org/file/directory_service;1"]. + getService(Ci.nsIProperties); + var file = dirs.get("TmpD", Ci.nsILocalFile); + file.append("tmpxpi"); + file.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0755); + var entries = zipReader.findEntries("*"); + while (entries.hasMore()) { + var path = entries.getNext(); + var entry = zipReader.getEntry(path); + if (path.substring(path.length - 1) == "/") + path = path.substring(0, entry.length - 1); + var parts = path.split("/"); + var target = file.clone(); + for (var i = 0; i < parts.length; i++) + target.append(parts[i]); + if (entry.isDirectory) { + if (!target.exists()) + target.create(Ci.nsIFile.DIRECTORY_TYPE, 0755); + } + else { + var parent = target.parent; + if (!parent.exists()) + parent.create(Ci.nsIFile.DIRECTORY_TYPE, 0755); + zipReader.extract(path, target); + } + } + zipReader.close(); + return file; +} + +function loadManifest(file) { + var ioServ = Cc["@mozilla.org/network/io-service;1"]. + getService(Ci.nsIIOService); + var fph = ioServ.getProtocolHandler("file") + .QueryInterface(Ci.nsIFileProtocolHandler); + return gRDF.GetDataSourceBlocking(fph.getURLSpecFromFile(file)); +} + +function recursiveUpdate(zipWriter, path, dir) { + var entries = dir.directoryEntries; + while (entries.hasMoreElements()) { + var entry = entries.getNext().QueryInterface(Ci.nsIFile); + if (entry.isDirectory()) { + var newPath = path + entry.leafName + "/"; + zipWriter.addEntryDirectory(newPath, entry.lastModifiedTime, false); + recursiveUpdate(zipWriter, newPath, entry); + } + else { + zipWriter.addEntryFile(path + entry.leafName, Ci.nsIZipWriter.COMPRESSION_NONE, + entry, false); + } + } +} + +function updateXPI(xpi, file) { + // XXX For 1.9 final we can switch to just extracting/compressing install.rdf + var zipWriter = Cc["@mozilla.org/zipwriter;1"]. + createInstance(Ci.nsIZipWriter); + zipWriter.open(xpi, 0x04 | 0x08 | 0x20); + recursiveUpdate(zipWriter, "", file); + zipWriter.close(); +} + +function nttAddonUpdateChecker(addon) { + this.addon = addon; +} + +nttAddonUpdateChecker.prototype = { + addon: null, + busy: null, + + checkForUpdates: function() { + this.busy = true; + LOG("Searching for compatibility information for " + this.addon.id); + gEM.update([this.addon], 1, + Ci.nsIExtensionManager.UPDATE_SYNC_COMPATIBILITY, this); + + // Spin an event loop to wait for the update check to complete. + var tm = Cc["@mozilla.org/thread-manager;1"]. + getService(Ci.nsIThreadManager); + var thread = tm.currentThread; + while (this.busy) + thread.processNextEvent(true); + }, + + // nsIAddonUpdateCheckListener implementation + onUpdateStarted: function() { + }, + + onUpdateEnded: function() { + this.busy = false; + }, + + onAddonUpdateStarted: function(addon) { + }, + + onAddonUpdateEnded: function(addon, status) { + if (status & Ci.nsIAddonUpdateCheckListener.STATUS_DATA_FOUND) { + LOG("Found new compatibility information for " + addon.id + ": " + addon.minAppVersion + " " + addon.maxAppVersion); + this.addon.minAppVersion = addon.minAppVersion; + this.addon.maxAppVersion = addon.maxAppVersion; + this.addon.targetAppID = addon.targetAppID; + this.addon.overrideVersions(); + } + } +}; + +function nttAddonDetail() { +} + +nttAddonDetail.prototype = { + datasource: null, + root: null, + + xpi: null, + file: null, + + id: null, + name: null, + version: null, + type: Ci.nsIUpdateItem.TYPE_EXTENSION, + updateRDF: null, + updateKey: null, + iconURL: "chrome://mozapps/skin/xpinstall/xpinstallItemGeneric.png", + + installLocationKey: null, + xpiURL: null, + xpiHash: null, + + appResource: null, + targetAppID: null, + minAppVersion: null, + maxAppVersion: null, + + init: function() { + if (!this.id) + this.id = getRDFProperty(this.datasource, this.root, "id"); + this.name = getRDFProperty(this.datasource, this.root, "name"); + this.version = getRDFProperty(this.datasource, this.root, "version"); + this.updateRDF = getRDFProperty(this.datasource, this.root, "updateURL"); + this.updateKey = getRDFProperty(this.datasource, this.root, "updateKey"); + + var apps = this.datasource.GetTargets(this.root, EM_R("targetApplication"), true); + while (apps.hasMoreElements()) { + var app = apps.getNext().QueryInterface(Ci.nsIRDFResource); + var id = getRDFProperty(this.datasource, app, "id"); + if (id == gApp.ID || id == TOOLKIT_ID) { + this.minAppVersion = getRDFProperty(this.datasource, app, "minVersion"); + this.maxAppVersion = getRDFProperty(this.datasource, app, "maxVersion"); + if (this.minAppVersion && this.maxAppVersion) { + this.appResource = app; + this.targetAppID = id; + if (id == gApp.ID) + break; + } + } + } + }, + + initWithXPI: function(xpi) { + this.xpi = xpi; + this.file = extractXPI(xpi); + var rdf = this.file.clone(); + rdf.append(FILE_INSTALL_MANIFEST); + this.datasource = loadManifest(rdf); + this.root = gRDF.GetResource(RDFURI_INSTALL_MANIFEST_ROOT); + this.init(); + }, + + initWithDataSource: function(ds, root, id) { + this.datasource = ds; + this.root = root; + this.id = id; + this.init(); + }, + + cleanup: function() { + if (this.file && this.file.exists) + this.file.remove(true); + }, + + overrideVersions: function() { + removeRDFProperty(this.datasource, this.appResource, "minVersion"); + this.datasource.Assert(this.appResource, EM_R("minVersion"), gRDF.GetLiteral(this.minAppVersion), true); + removeRDFProperty(this.datasource, this.appResource, "maxVersion"); + this.datasource.Assert(this.appResource, EM_R("maxVersion"), gRDF.GetLiteral(this.maxAppVersion), true); + this.datasource.QueryInterface(Ci.nsIRDFRemoteDataSource).Flush(); + if (this.xpi && this.file) + updateXPI(this.xpi, this.file); + }, + + overrideCompatibility: function(ignorePrefs) { + if (!this.isValid()) + return; + + var changed = false; + + if (gCheckCompatibility || ignorePrefs) { + var version = (gApp.ID == this.targetAppID) ? gApp.version : gApp.platformVersion; + if (gVC.compare(version, this.minAppVersion) < 0) { + LOG("minVersion " + this.minAppVersion + " is too high, reducing to " + version); + if (!this.datasource.GetTarget(this.appResource, EM_R("oldMinVersion"), true)) + this.datasource.Assert(this.appResource, EM_R("oldMinVersion"), gRDF.GetLiteral(this.minAppVersion), true); + removeRDFProperty(this.datasource, this.appResource, "minVersion"); + this.datasource.Assert(this.appResource, EM_R("minVersion"), gRDF.GetLiteral(version), true); + this.minAppVersion = version; + changed = true; + } + else if (gVC.compare(version, this.maxAppVersion) > 0) { + LOG("maxVersion " + this.maxAppVersion + " is too low, increasing to " + version); + if (!this.datasource.GetTarget(this.appResource, EM_R("oldMaxVersion"), true)) + this.datasource.Assert(this.appResource, EM_R("oldMaxVersion"), gRDF.GetLiteral(this.maxAppVersion), true); + removeRDFProperty(this.datasource, this.appResource, "maxVersion"); + this.datasource.Assert(this.appResource, EM_R("maxVersion"), gRDF.GetLiteral(version), true); + this.maxAppVersion = version; + changed = true; + } + + if (changed && !this.xpi) { + // This updates any UI bound to the datasource + var compatprop = EM_R("compatible"); + var truth = gRDF.GetLiteral("true"); + this.datasource.Assert(this.root, compatprop, truth, true); + this.datasource.Unassert(this.root, compatprop, truth); + } + } + + if (!this.isUpdateSecure(ignorePrefs)) { + LOG("Addon is insecure, removing update URL"); + removeRDFProperty(this.datasource, this.root, "updateURL"); + this.updateRDF = null; + changed = true; + + // This updates any UI bound to the datasource + compatprop = EM_R("providesUpdatesSecurely"); + truth = gRDF.GetLiteral("true"); + this.datasource.Assert(this.root, compatprop, truth, true); + this.datasource.Unassert(this.root, compatprop, truth); + } + + if (changed) { + this.datasource.QueryInterface(Ci.nsIRDFRemoteDataSource).Flush(); + if (this.xpi && this.file) + updateXPI(this.xpi, this.file); + } + }, + + isValid: function() { + return !!this.appResource; + }, + + isCompatible: function(ignorePrefs) { + if (!gCheckCompatibility && !ignorePrefs) + return true; + + var version = (gApp.ID == this.targetAppID) ? gApp.version : gApp.platformVersion; + if (gVC.compare(version, this.minAppVersion) < 0) + return false; + if (gVC.compare(version, this.maxAppVersion) > 0) + return false; + return true; + }, + + isUpdateSecure: function(ignorePrefs) { + if (!gCheckUpdateSecurity && !ignorePrefs) + return true; + + if (!this.updateRDF) + return true; + if (this.updateKey) + return true; + return (this.updateRDF.substring(0, 6) == "https:"); + }, + + needsOverride: function(ignorePrefs) { + return (!this.isCompatible(ignorePrefs) || !this.isUpdateSecure(ignorePrefs)); + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nttIAddon, Ci.nsIUpdateItem]), +}; + +function nttAddonCompatibilityService() { +} + +nttAddonCompatibilityService.prototype = { + id: null, + + init: function() { + Components.utils.import("resource://nightly/Logging.jsm"); + + gEM = Cc["@mozilla.org/extensions/manager;1"]. + getService(Ci.nsIExtensionManager); + gRDF = Cc["@mozilla.org/rdf/rdf-service;1"]. + getService(Ci.nsIRDFService); + gApp = Cc["@mozilla.org/xre/app-info;1"]. + getService(Ci.nsIXULAppInfo).QueryInterface(Ci.nsIXULRuntime); + gVC = Cc["@mozilla.org/xpcom/version-comparator;1"]. + getService(Ci.nsIVersionComparator); + if (gVC.compare(gApp.platformVersion, "1.9b5") >= 0) + this.id = gEM.addInstallListener(this); + gPrefs = Components.classes["@mozilla.org/preferences-service;1"] + .getService(Components.interfaces.nsIPrefService) + .getBranch("extensions.") + .QueryInterface(Components.interfaces.nsIPrefBranch2); + try { + gCheckCompatibility = gPrefs.getBoolPref("checkCompatibility"); + } + catch (e) { } + try { + gCheckUpdateSecurity = gPrefs.getBoolPref("checkUpdateSecurity"); + } + catch (e) { } + gPrefs.addObserver("", this, false); + }, + + // nsIAddonCompatibilityService implementation + getAddonForID: function(id) { + var addon = new nttAddonDetail(); + addon.initWithDataSource(gEM.datasource, gRDF.GetResource(PREFIX_ITEM_URI + id), id); + return addon; + }, + + confirmOverride: function(addons, count) { + var wm = Cc["@mozilla.org/appshell/window-mediator;1"]. + getService(Ci.nsIWindowMediator); + win = wm.getMostRecentWindow("Extension:Manager"); + if (win && win.top) + win = win.top; + + var params = Cc["@mozilla.org/array;1"]. + createInstance(Ci.nsIMutableArray); + for (var i = 0; i < addons.length; i++) + params.appendElement(addons[i], false); + var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"]. + getService(Ci.nsIWindowWatcher); + ww.openWindow(win, "chrome://nightly/content/extensions/incompatible.xul", "", + "chrome,centerscreen,modal,dialog,titlebar", params); + return true; + }, + + // nsIAddonInstallListener implementation + onDownloadStarted: function(addon) { + }, + + onDownloadProgress: function(addon, value, maxValue) { + }, + + onDownloadEnded: function(addon) { + }, + + onInstallStarted: function(addon) { + LOG("Install Started for " + addon.xpiURL); + var ioServ = Cc["@mozilla.org/network/io-service;1"]. + getService(Ci.nsIIOService); + var fph = ioServ.getProtocolHandler("file") + .QueryInterface(Ci.nsIFileProtocolHandler); + var file = fph.getFileFromURLSpec(addon.xpiURL); + if (file.exists()) { + try { + var addon = new nttAddonDetail(); + addon.initWithXPI(file); + if (addon.isValid()) { + if (!addon.isCompatible(false)) { + // Check if there are remote updates available + var checker = new nttAddonUpdateChecker(addon); + checker.checkForUpdates(); + } + + if (addon.needsOverride(false)) + this.confirmOverride([addon], 1); + else + LOG("Add-on is already compatible: '" + addon.updateRDF + "' " + addon.minAppVersion + "-" + addon.maxAppVersion); + } + else { + WARN("Add-on seems to be invalid"); + } + addon.cleanup(); + } + catch (e) { + ERROR("Exception during compatibility check " + e); + } + } + }, + + onCompatibilityCheckStarted: function(addon) { + }, + + onCompatibilityCheckEnded: function(addon, status) { + }, + + onInstallEnded: function(addon, status) { + }, + + onInstallsCompleted: function() { + }, + + // nsIObserver implementation + observe: function(subject, topic, data) { + switch (topic) { + case "app-startup": + var os = Cc["@mozilla.org/observer-service;1"]. + getService(Ci.nsIObserverService); + os.addObserver(this, "profile-after-change", false); + os.addObserver(this, "quit-application", false); + break; + case "profile-after-change": + this.init(); + break; + case "quit-application": + if (this.id) + gEM.removeInstallListenerAt(this.id); + gEM = null; + gRDF = null; + gApp = null; + gVC = null; + gPrefs.removeObserver("", this); + gPrefs = null; + break; + case "nsPref:changed": + switch (data) { + case "checkCompatibility": + try { + gCheckCompatibility = gPrefs.getBoolPref(data); + } + catch (e) { + gCheckCompatibility = true; + } + break; + case "checkUpdateSecurity": + try { + gCheckUpdateSecurity = gPrefs.getBoolPref(data); + } + catch (e) { + gCheckUpdateSecurity = true; + } + break; + } + break; + default: + WARN("Unknown event " + topic); + } + }, + + classDescription: "Nightly Tester Install Monitor", + contractID: "@oxymoronical.com/nightly/addoncompatibility;1", + classID: Components.ID("{801207d5-037c-4565-80ed-ede8f7a7c100}"), + QueryInterface: XPCOMUtils.generateQI([Ci.nttIAddonCompatibilityService, Ci.nsIAddonInstallListener, Ci.nsIObserver]), + _xpcom_categories: [{ + category: "app-startup", + service: true + }] +} + +function NSGetModule(compMgr, fileSpec) + XPCOMUtils.generateModule([nttAddonCompatibilityService]); diff -r 000000000000 -r dada0ac40a8f components/nttBreakpadService.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/components/nttBreakpadService.js Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,265 @@ +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cr = Components.results; + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +const LOAD_DELAY = 50; + +Cc["@mozilla.org/moz/jssubscript-loader;1"] + .getService(Ci.mozIJSSubScriptLoader) + .loadSubScript("chrome://nightly/content/includes/tree-utils.js", null); + +function BP_CreateArray(source) +{ + var result = Cc["@mozilla.org/array;1"] + .createInstance(Ci.nsIMutableArray); + + for (var key in source) + result.appendElement(source[key], false); + + return result; +} + +function nttBreakpadIncident(file) +{ + this.id = file.leafName; + this.id = this.id.substring(0, this.id.length - 4); + this.date = file.lastModifiedTime; + this.file = file; +} + +nttBreakpadIncident.prototype = { +date: null, +id: null, +file: null, + +QueryInterface: XPCOMUtils.generateQI([Ci.nttIBreakpadIncident]) +} + +function nttBreakpadService() { + var obs = Cc["@mozilla.org/observer-service;1"] + .getService(Ci.nsIObserverService); + obs.addObserver(this, "quit-application", false); + + this._dirs = []; + this._databases = []; + this._listeners = []; + this._incidents = []; + this._orderedIncidents = []; + + this._findBreakpad(); + if (this.reportdir) + this._dirs.push(this.reportdir); + else + { + this.loaded = true; + this._loading = true; + } +} + +nttBreakpadService.prototype = { + +reportdir: null, + +loaded: false, +_loading: false, +_dirs: null, +_databases: null, +_loadTimer: null, +_listeners: null, + +incidents: null, +orderedIncidents: null, + +addProgressListener: function(listener) +{ + if (!this.loaded) + this._listeners.push(listener); + else + listener.onDatabaseLoaded(); +}, + +loadDatabase: function() +{ + if (this._loading) + return; + + this._loading = true; + + if (this.reportdir && this.reportdir.exists()) + { + this.incidents = []; + this.orderedIncidents = []; + + this._loadTimer = Cc["@mozilla.org/timer;1"] + .createInstance(Ci.nsITimer); + this._loadTimer.init(this, LOAD_DELAY, Components.interfaces.nsITimer.TYPE_ONE_SHOT); + } + else + this.loaded = true; +}, + +observe: function(subject, topic, data) +{ + switch (topic) + { + case "quit-application": + if (this._loadTimer) + { + // Shutdown during load, clear references + this._loadTimer.cancel(); + this._loadTimer = null; + this._databases = []; + this._dirs = []; + this._listeners = []; + } + var obs = Cc["@mozilla.org/observer-service;1"] + .getService(Ci.nsIObserverService); + obs.removeObserver(this, "quit-application"); + break; + case "timer-callback": + this.run(); + break; + } +}, + +run: function() +{ + if (this._dirs.length>0) + this._scanDir(this._dirs.pop()); + else if (this._databases.length>0) + this._loadDatabase(this._databases.pop()); + else + { + this.loaded = true; + if (this._listeners.length == 0) { + this._loadTimer = null; + return; + } + var listener = this._listeners.pop(); + listener.onDatabaseLoaded(); + if (this._listeners.length == 0) { + this._loadTimer = null; + return; + } + } + this._loadTimer.init(this, LOAD_DELAY, Components.interfaces.nsITimer.TYPE_ONE_SHOT); +}, + +_scanDir: function(dir) +{ + var entries = dir.directoryEntries; + while (entries.hasMoreElements()) + { + var ndir = entries.getNext().QueryInterface(Ci.nsIFile); + if (ndir.isDirectory()) + this._dirs.push(ndir); + else + { + var ext = ndir.leafName; + ext = ext.substring(ext.length - 4); + if (ext == ".txt") + this._databases.push(ndir); + } + } +}, + +_loadDatabase: function(database) +{ + var incident = new nttBreakpadIncident(database); + this._addIncident(incident); +}, + +_findBreakpad: function() +{ + var directoryService = Cc["@mozilla.org/file/directory_service;1"] + .getService(Ci.nsIProperties); + var dir = directoryService.get("DefProfRt", Ci.nsIFile); + if (dir.leafName.toLowerCase() == "profiles") + dir = dir.parent; + dir.append("Crash Reports"); + if (dir.exists() && dir.isDirectory()) + this.reportdir = dir; +}, + +_addIncident: function(incident) +{ + var pos = 0; + while ((pos < this.orderedIncidents.length) && (this.orderedIncidents[pos].date > incident.date)) + pos++; + + this.orderedIncidents.splice(pos, 0, incident); + this.incidents[incident.id]=incident; +}, + +getRecentIncidents: function(date) +{ + var result = Cc["@mozilla.org/array;1"] + .createInstance(Ci.nsIMutableArray); + + for (var i = 0; i < this.orderedIncidents.length; i++) + { + if (this.orderedIncidents[i].date> 4); + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); + chr3 = ((enc3 & 3) << 6) | enc4; + + output = output + String.fromCharCode(chr1); + + if (enc3 != 64) + { + output = output + String.fromCharCode(chr2); + } + if (enc4 != 64) + { + output = output + String.fromCharCode(chr3); + } + } + while (i < input.length); + + return output; +} + +function MultipartFormData() +{ + this.boundary = "hsdluicmwos"; + this.controls = []; + this.files = []; + this.postdata = ""; +} + +MultipartFormData.prototype = { + +boundary: null, +controls: null, +files: null, +length: null, +postdata: null, + +getPostData: function() +{ + if (this.postdata) + return this.postdata; + + var data = ""; + + for (var name in this.controls) + { + data+="\r\n--"+this.boundary+"\r\n"; + data+="Content-Disposition: form-data; name=\""+name+"\"\r\n\r\n"; + data+=this.controls[name]; + } + + for (var name in this.files) + { + var filedata = this.files[name]; + data+="\r\n--"+this.boundary+"\r\n"; + data+="Content-Disposition: form-data; name=\""+name+"\"; filename=\""+filedata.filename+"\"\r\n"; + data+="Content-Type: "+filedata.contenttype+"\r\n"; + if (filedata.source) + { + data+="Content-Transfer-Encoding: base64\r\n\r\n"; + + var fis = Cc["@mozilla.org/network/file-input-stream;1"] + .createInstance(Ci.nsIFileInputStream); + fis.init(filedata.source, 1, 384, Ci.nsIFileInputStream.CLOSE_ON_EOF); + + var bis = Cc["@mozilla.org/binaryinputstream;1"] + .createInstance(Ci.nsIBinaryInputStream); + bis.setInputStream(fis); + + //TODO this isnt needed as yet + } + else + { + data+="Content-Transfer-Encoding: binary\r\n\r\n"; + if (filedata.encoding == "base64") + { + data+=NTT_decode64(filedata.data); + } + else if (filedata.encoding == "binary") + { + data+=filedata.data; + } + } + } + data+="\r\n--"+this.boundary+"--\r\n"; + + this.length = data.length-2; + this.postdata = data; + + return data; +}, + +getPostDataStream: function() +{ + return NTT_MakeStream(this.getPostData()); +}, + +getHeaders: function() +{ + if (!this.length) + this.getPostData(); + + var headers = ""; + headers+="Content-Type: "+this.getContentType()+"\r\n"; + headers+="Content-Length: "+this.length+"\r\n"; + return headers; +}, + +getHeaderStream: function() +{ + return NTT_MakeStream(this.getHeaders()); +}, + +getContentType: function() +{ + return "multipart/form-data; boundary=\""+this.boundary+"\""; +}, + +addControl: function(name, value) +{ + this.controls[name]=value; + this.postdata = null; + this.length = null; +}, + +addFile: function(name, contenttype, file) +{ + throw Components.results.NS_NOT_IMPLEMENTED; + var filedata = { + filename: file.leafName, + contenttype: contenttype, + source: file + }; + this.files[name] = filedata; + this.postdata = null; + this.length = null; +}, + +addFileData: function(name, filename, contenttype, encoding, data) +{ + var filedata = { + filename: filename, + contenttype: contenttype, + encoding: encoding, + data: data + }; + this.files[name] = filedata; + this.postdata = null; + this.length = null; +}, + +classDescription: "Nightly Tester Multipart Form Data", +contractID: "@blueprintit.co.uk/multipartformdata;1", +classID: Components.ID("{46c8b0c6-216c-41e8-ace2-03d61783e278}"), +QueryInterface: XPCOMUtils.generateQI([Ci.nttIMultipartFormData]) +} + +function NSGetModule(compMgr, fileSpec) + XPCOMUtils.generateModule([MultipartFormData]); diff -r 000000000000 -r dada0ac40a8f defaults/preferences/nightlytools.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/defaults/preferences/nightlytools.js Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,16 @@ +pref("nightly.idtitle", true); + +pref("nightly.showEnableAll", true); + +pref("nightly.leaks.showleaklog", false); +pref("nightly.leaks.filterDocshell", true); +pref("nightly.leaks.filterDocument", true); +pref("nightly.leaks.filterWindow", true); +pref("nightly.leaks.filterLeaked", true); +pref("nightly.leaks.filterCollected", true); +pref("nightly.leaks.filterIgnored", true); + +pref("nightly.crashreports.recentlist.display", true); +pref("nightly.breakpad.searchurl", "http://crash-stats.mozilla.com/report/index/"); + +pref("extensions.{8620c15f-30dc-4dba-a131-7c5d20cf4a29}.description", "chrome://nightly/locale/nightly.properties"); diff -r 000000000000 -r dada0ac40a8f defaults/preferences/variables.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/defaults/preferences/variables.js Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,2 @@ +pref("nightly.templates.buildid", "${UserAgent} ID:${AppBuildID}${Flags}"); +pref("nightly.templates.title", "${DefaultTitle} (Build ${AppBuildID})"); diff -r 000000000000 -r dada0ac40a8f install.rdf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/install.rdf Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,62 @@ + + + + + + {8620c15f-30dc-4dba-a131-7c5d20cf4a29} + 2.0.2 + + + + + {ec8030f7-c20a-464f-9b0e-13a3a9e97384} + 3.0b5 + 3.0pre + + + + + + + {3550f703-e582-4d05-9a08-453d09bdfdc6} + 3.0a1 + 3.0a1 + + + + + + + + {92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a} + 2.0a1pre + 2.0a1pre + + + + + + + songbird@songbirdnest.com + 0.6pre + 0.6pre + + + + + Nightly Tester Tools + Useful tools for the nightly tester. + Mossop + Peter van der Woude (original idea) + Jesse Ruderman (Mac fixes) + Steve England (QA) + Stephen Lau (Songbird port) + FAMFAMFAM (Some icons) + + chrome://nightly/content/brand/icon.png + chrome://nightly/content/options/options.xul + http://www.oxymoronical.com/web/firefox/nightly + + + diff -r 000000000000 -r dada0ac40a8f modules/Logging.jsm --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/modules/Logging.jsm Tue Dec 02 20:31:01 2008 +0900 @@ -0,0 +1,70 @@ +var EXPORTED_SYMBOLS = ["LOG", "WARN", "ERROR"]; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cr = Components.results; + +var gLoggingEnabled = false; + +function logMessage(text, level) { + var caller = null; + try { + caller = Components.stack.caller.caller; + } + catch (e) { } + + var msg = Cc["@mozilla.org/scripterror;1"]. + createInstance(Ci.nsIScriptError); + if (caller) { + var filename = caller.filename; + var sourceLine = caller.sourceLine; + var lineNumber = caller.lineNumber; + } + else { + var filename = ""; + var sourceLine = ""; + var lineNumber = 0; + } + msg.init(text, filename, sourceLine, lineNumber, 0, + level, "XUL JavaScript"); + + var console = Cc["@mozilla.org/consoleservice;1"]. + getService(Ci.nsIConsoleService); + console.logMessage(msg); +} + +function ERROR(string) { + dump("NTT ERROR: " + string + "\n"); + logMessage("NTT: " + string, Ci.nsIScriptError.errorFlag); +} + +function WARN(string) { + dump("NTT WARN : " + string + "\n"); + logMessage("NTT: " + string, Ci.nsIScriptError.warningFlag); +} + +function LOG(string) { + if (gLoggingEnabled) { + dump("NTT LOG : " + string + "\n"); + + var caller = null; + try { + caller = Components.stack.caller; + } + catch (e) { } + + if (caller) + string += " (" + caller.filename + ":" + caller.lineNumber + ")"; + + var console = Cc["@mozilla.org/consoleservice;1"]. + getService(Ci.nsIConsoleService); + console.logStringMessage("NTT: " + string); + } +} + +var prefs = Cc["@mozilla.org/preferences-service;1"]. + getService(Ci.nsIPrefBranch); +try { + gLoggingEnabled = prefs.getBoolPref("nightly.logging"); +} +catch (e) { }