diff options
Diffstat (limited to 'toolkit/components/timermanager')
7 files changed, 952 insertions, 0 deletions
diff --git a/toolkit/components/timermanager/moz.build b/toolkit/components/timermanager/moz.build new file mode 100644 index 000000000..9977df6b5 --- /dev/null +++ b/toolkit/components/timermanager/moz.build @@ -0,0 +1,21 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPIDL_MODULE = 'update' + +XPCSHELL_TESTS_MANIFESTS += ['tests/unit/xpcshell.ini'] + +XPIDL_SOURCES += [ + 'nsIUpdateTimerManager.idl', +] + +EXTRA_COMPONENTS += [ + 'nsUpdateTimerManager.js', + 'nsUpdateTimerManager.manifest', +] + +with Files('**'): + BUG_COMPONENT = ('Toolkit', 'Application Update') diff --git a/toolkit/components/timermanager/nsIUpdateTimerManager.idl b/toolkit/components/timermanager/nsIUpdateTimerManager.idl new file mode 100644 index 000000000..6f9e2d169 --- /dev/null +++ b/toolkit/components/timermanager/nsIUpdateTimerManager.idl @@ -0,0 +1,54 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "nsISupports.idl" + +interface nsITimerCallback; + +/** + * An interface describing a global application service that allows long + * duration (e.g. 1-7 or more days, weeks or months) timers to be registered + * and then fired. + */ +[scriptable, uuid(0765c92c-6145-4253-9db4-594d8023087e)] +interface nsIUpdateTimerManager : nsISupports +{ + /** + * Register an interval with the timer manager. The timer manager + * periodically checks to see if the interval has expired and if it has + * calls the specified callback. This is persistent across application + * restarts and can handle intervals of long durations. + * @param id + * An id that identifies the interval, used for persistence + * @param callback + * A nsITimerCallback object that is notified when the interval + * expires + * @param interval + * The length of time, in seconds, of the interval + * + * Note: to avoid having to instantiate a component to call registerTimer + * the component can intead register an update-timer category with comma + * separated values as a single string representing the timer as follows. + * + * _xpcom_categories: [{ category: "update-timer", + * value: "contractID," + + * "method," + + * "id," + + * "preference," + + * "interval" }], + * the values are as follows + * contractID : the contract ID for the component. + * method : the method used to instantiate the interface. This should be + * either getService or createInstance depending on your + * component. + * id : the id that identifies the interval, used for persistence. + * preference : the preference to for timer interval. This value can be + * optional by specifying an empty string for the value. + * interval : the default interval in seconds for the timer. + */ + void registerTimer(in AString id, + in nsITimerCallback callback, + in unsigned long interval); +}; diff --git a/toolkit/components/timermanager/nsUpdateTimerManager.js b/toolkit/components/timermanager/nsUpdateTimerManager.js new file mode 100644 index 000000000..d7fc15960 --- /dev/null +++ b/toolkit/components/timermanager/nsUpdateTimerManager.js @@ -0,0 +1,339 @@ +/* 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/. */ + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm", this); +Components.utils.import("resource://gre/modules/Services.jsm", this); + +const Cc = Components.classes; +const Ci = Components.interfaces; + +const PREF_APP_UPDATE_LASTUPDATETIME_FMT = "app.update.lastUpdateTime.%ID%"; +const PREF_APP_UPDATE_TIMERMINIMUMDELAY = "app.update.timerMinimumDelay"; +const PREF_APP_UPDATE_TIMERFIRSTINTERVAL = "app.update.timerFirstInterval"; +const PREF_APP_UPDATE_LOG = "app.update.log"; + +const CATEGORY_UPDATE_TIMER = "update-timer"; + +XPCOMUtils.defineLazyGetter(this, "gLogEnabled", function tm_gLogEnabled() { + return getPref("getBoolPref", PREF_APP_UPDATE_LOG, false); +}); + +/** + * Gets a preference value, handling the case where there is no default. + * @param func + * The name of the preference function to call, on nsIPrefBranch + * @param preference + * The name of the preference + * @param defaultValue + * The default value to return in the event the preference has + * no setting + * @returns The value of the preference, or undefined if there was no + * user or default value. + */ +function getPref(func, preference, defaultValue) { + try { + return Services.prefs[func](preference); + } catch (e) { + } + return defaultValue; +} + +/** + * Logs a string to the error console. + * @param string + * The string to write to the error console. + */ +function LOG(string) { + if (gLogEnabled) { + dump("*** UTM:SVC " + string + "\n"); + Services.console.logStringMessage("UTM:SVC " + string); + } +} + +/** + * A manager for timers. Manages timers that fire over long periods of time + * (e.g. days, weeks, months). + * @constructor + */ +function TimerManager() { + Services.obs.addObserver(this, "xpcom-shutdown", false); +} +TimerManager.prototype = { + /** + * The Checker Timer + */ + _timer: null, + + /** + * The Checker Timer minimum delay interval as specified by the + * app.update.timerMinimumDelay pref. If the app.update.timerMinimumDelay + * pref doesn't exist this will default to 120000. + */ + _timerMinimumDelay: null, + + /** + * The set of registered timers. + */ + _timers: { }, + + /** + * See nsIObserver.idl + */ + observe: function TM_observe(aSubject, aTopic, aData) { + // Prevent setting the timer interval to a value of less than 30 seconds. + var minInterval = 30000; + // Prevent setting the first timer interval to a value of less than 10 + // seconds. + var minFirstInterval = 10000; + switch (aTopic) { + case "utm-test-init": + // Enforce a minimum timer interval of 500 ms for tests and fall through + // to profile-after-change to initialize the timer. + minInterval = 500; + minFirstInterval = 500; + case "profile-after-change": + this._timerMinimumDelay = Math.max(1000 * getPref("getIntPref", PREF_APP_UPDATE_TIMERMINIMUMDELAY, 120), + minInterval); + // Prevent the timer delay between notifications to other consumers from + // being greater than 5 minutes which is 300000 milliseconds. + this._timerMinimumDelay = Math.min(this._timerMinimumDelay, 300000); + // Prevent the first interval from being less than the value of minFirstInterval + let firstInterval = Math.max(getPref("getIntPref", PREF_APP_UPDATE_TIMERFIRSTINTERVAL, + 30000), minFirstInterval); + // Prevent the first interval from being greater than 2 minutes which is + // 120000 milliseconds. + firstInterval = Math.min(firstInterval, 120000); + // Cancel the timer if it has already been initialized. This is primarily + // for tests. + this._canEnsureTimer = true; + this._ensureTimer(firstInterval); + break; + case "xpcom-shutdown": + Services.obs.removeObserver(this, "xpcom-shutdown"); + + // Release everything we hold onto. + this._cancelTimer(); + for (var timerID in this._timers) { + delete this._timers[timerID]; + } + this._timers = null; + break; + } + }, + + /** + * Called when the checking timer fires. + * + * We only fire one notification each time, so that the operations are + * staggered. We don't want too many to happen at once, which could + * negatively impact responsiveness. + * + * @param timer + * The checking timer that fired. + */ + notify: function TM_notify(timer) { + var nextDelay = null; + function updateNextDelay(delay) { + if (nextDelay === null || delay < nextDelay) { + nextDelay = delay; + } + } + + // Each timer calls tryFire(), which figures out which is the one that + // wanted to be called earliest. That one will be fired; the others are + // skipped and will be done later. + var now = Math.round(Date.now() / 1000); + + var callbackToFire = null; + var earliestIntendedTime = null; + var skippedFirings = false; + var lastUpdateTime = null; + function tryFire(callback, intendedTime) { + var selected = false; + if (intendedTime <= now) { + if (intendedTime < earliestIntendedTime || + earliestIntendedTime === null) { + callbackToFire = callback; + earliestIntendedTime = intendedTime; + selected = true; + } else if (earliestIntendedTime !== null) { + skippedFirings = true; + } + } + // We do not need to updateNextDelay for the timer that actually fires; + // we'll update right after it fires, with the proper intended time. + // Note that we might select one, then select another later (with an + // earlier intended time); it is still ok that we did not update for + // the first one, since if we have skipped firings, the next delay + // will be the minimum delay anyhow. + if (!selected) { + updateNextDelay(intendedTime - now); + } + } + + var catMan = Cc["@mozilla.org/categorymanager;1"]. + getService(Ci.nsICategoryManager); + var entries = catMan.enumerateCategory(CATEGORY_UPDATE_TIMER); + while (entries.hasMoreElements()) { + let entry = entries.getNext().QueryInterface(Ci.nsISupportsCString).data; + let value = catMan.getCategoryEntry(CATEGORY_UPDATE_TIMER, entry); + let [cid, method, timerID, prefInterval, defaultInterval, maxInterval] = value.split(","); + + defaultInterval = parseInt(defaultInterval); + // cid and method are validated below when calling notify. + if (!timerID || !defaultInterval || isNaN(defaultInterval)) { + LOG("TimerManager:notify - update-timer category registered" + + (cid ? " for " + cid : "") + " without required parameters - " + + "skipping"); + continue; + } + + let interval = getPref("getIntPref", prefInterval, defaultInterval); + // Allow the update-timer category to specify a maximum value to prevent + // values larger than desired. + maxInterval = parseInt(maxInterval); + if (maxInterval && !isNaN(maxInterval)) { + interval = Math.min(interval, maxInterval); + } + let prefLastUpdate = PREF_APP_UPDATE_LASTUPDATETIME_FMT.replace(/%ID%/, + timerID); + // Initialize the last update time to 0 when the preference isn't set so + // the timer will be notified soon after a new profile's first use. + lastUpdateTime = getPref("getIntPref", prefLastUpdate, 0); + + // If the last update time is greater than the current time then reset + // it to 0 and the timer manager will correct the value when it fires + // next for this consumer. + if (lastUpdateTime > now) { + lastUpdateTime = 0; + } + + if (lastUpdateTime == 0) { + Services.prefs.setIntPref(prefLastUpdate, lastUpdateTime); + } + + tryFire(function () { + try { + Components.classes[cid][method](Ci.nsITimerCallback).notify(timer); + LOG("TimerManager:notify - notified " + cid); + } catch (e) { + LOG("TimerManager:notify - error notifying component id: " + + cid + " ,error: " + e); + } + lastUpdateTime = now; + Services.prefs.setIntPref(prefLastUpdate, lastUpdateTime); + updateNextDelay(lastUpdateTime + interval - now); + }, lastUpdateTime + interval); + } + + for (let _timerID in this._timers) { + let timerID = _timerID; // necessary for the closure to work properly + let timerData = this._timers[timerID]; + // If the last update time is greater than the current time then reset + // it to 0 and the timer manager will correct the value when it fires + // next for this consumer. + if (timerData.lastUpdateTime > now) { + let prefLastUpdate = PREF_APP_UPDATE_LASTUPDATETIME_FMT.replace(/%ID%/, timerID); + timerData.lastUpdateTime = 0; + Services.prefs.setIntPref(prefLastUpdate, timerData.lastUpdateTime); + } + tryFire(function () { + if (timerData.callback && timerData.callback.notify) { + try { + timerData.callback.notify(timer); + LOG("TimerManager:notify - notified timerID: " + timerID); + } catch (e) { + LOG("TimerManager:notify - error notifying timerID: " + timerID + + ", error: " + e); + } + } else { + LOG("TimerManager:notify - timerID: " + timerID + " doesn't " + + "implement nsITimerCallback - skipping"); + } + lastUpdateTime = now; + timerData.lastUpdateTime = lastUpdateTime; + let prefLastUpdate = PREF_APP_UPDATE_LASTUPDATETIME_FMT.replace(/%ID%/, timerID); + Services.prefs.setIntPref(prefLastUpdate, lastUpdateTime); + updateNextDelay(timerData.lastUpdateTime + timerData.interval - now); + }, timerData.lastUpdateTime + timerData.interval); + } + + if (callbackToFire) { + callbackToFire(); + } + + if (nextDelay !== null) { + if (skippedFirings) { + timer.delay = this._timerMinimumDelay; + } else { + timer.delay = Math.max(nextDelay * 1000, this._timerMinimumDelay); + } + this.lastTimerReset = Date.now(); + } else { + this._cancelTimer(); + } + }, + + /** + * Starts the timer, if necessary, and ensures that it will fire soon enough + * to happen after time |interval| (in milliseconds). + */ + _ensureTimer: function (interval) { + if (!this._canEnsureTimer) { + return; + } + if (!this._timer) { + this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + this._timer.initWithCallback(this, interval, + Ci.nsITimer.TYPE_REPEATING_SLACK); + this.lastTimerReset = Date.now(); + } else if (Date.now() + interval < this.lastTimerReset + this._timer.delay) { + this._timer.delay = Math.max(this.lastTimerReset + interval - Date.now(), 0); + } + }, + + /** + * Stops the timer, if it is running. + */ + _cancelTimer: function () { + if (this._timer) { + this._timer.cancel(); + this._timer = null; + } + }, + + /** + * See nsIUpdateTimerManager.idl + */ + registerTimer: function TM_registerTimer(id, callback, interval) { + LOG("TimerManager:registerTimer - id: " + id); + if (id in this._timers && callback != this._timers[id].callback) { + LOG("TimerManager:registerTimer - Ignoring second registration for " + id); + return; + } + let prefLastUpdate = PREF_APP_UPDATE_LASTUPDATETIME_FMT.replace(/%ID%/, id); + // Initialize the last update time to 0 when the preference isn't set so + // the timer will be notified soon after a new profile's first use. + let lastUpdateTime = getPref("getIntPref", prefLastUpdate, 0); + let now = Math.round(Date.now() / 1000); + if (lastUpdateTime > now) { + lastUpdateTime = 0; + } + if (lastUpdateTime == 0) { + Services.prefs.setIntPref(prefLastUpdate, lastUpdateTime); + } + this._timers[id] = {callback: callback, + interval: interval, + lastUpdateTime: lastUpdateTime}; + + this._ensureTimer(interval * 1000); + }, + + classID: Components.ID("{B322A5C0-A419-484E-96BA-D7182163899F}"), + QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdateTimerManager, + Ci.nsITimerCallback, + Ci.nsIObserver]) +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([TimerManager]); diff --git a/toolkit/components/timermanager/nsUpdateTimerManager.manifest b/toolkit/components/timermanager/nsUpdateTimerManager.manifest new file mode 100644 index 000000000..73cb11e35 --- /dev/null +++ b/toolkit/components/timermanager/nsUpdateTimerManager.manifest @@ -0,0 +1,3 @@ +component {B322A5C0-A419-484E-96BA-D7182163899F} nsUpdateTimerManager.js +contract @mozilla.org/updates/timer-manager;1 {B322A5C0-A419-484E-96BA-D7182163899F} +category profile-after-change nsUpdateTimerManager @mozilla.org/updates/timer-manager;1 diff --git a/toolkit/components/timermanager/tests/unit/.eslintrc.js b/toolkit/components/timermanager/tests/unit/.eslintrc.js new file mode 100644 index 000000000..d35787cd2 --- /dev/null +++ b/toolkit/components/timermanager/tests/unit/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + "extends": [ + "../../../../../testing/xpcshell/xpcshell.eslintrc.js" + ] +}; diff --git a/toolkit/components/timermanager/tests/unit/consumerNotifications.js b/toolkit/components/timermanager/tests/unit/consumerNotifications.js new file mode 100644 index 000000000..b9926e11e --- /dev/null +++ b/toolkit/components/timermanager/tests/unit/consumerNotifications.js @@ -0,0 +1,519 @@ +/* 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/. + */ + +/* General Update Timer Manager Tests */ + +'use strict'; + +const { classes: Cc, interfaces: Ci, manager: Cm, results: Cr, + utils: Cu } = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +const CATEGORY_UPDATE_TIMER = "update-timer"; + +const PREF_APP_UPDATE_TIMERMINIMUMDELAY = "app.update.timerMinimumDelay"; +const PREF_APP_UPDATE_TIMERFIRSTINTERVAL = "app.update.timerFirstInterval"; +const PREF_APP_UPDATE_LOG_ALL = "app.update.log.all"; +const PREF_BRANCH_LAST_UPDATE_TIME = "app.update.lastUpdateTime."; + +const MAIN_TIMER_INTERVAL = 1000; // milliseconds +const CONSUMER_TIMER_INTERVAL = 1; // seconds + +const TESTS = [ { + desc: "Test Timer Callback 0", + timerID: "test0-update-timer", + defaultInterval: "bogus", + prefInterval: "test0.timer.interval", + contractID: "@mozilla.org/test0/timercallback;1", + method: "createInstance", + classID: Components.ID("9c7ce81f-98bb-4729-adb4-4d0deb0f59e5"), + notified: false +}, { + desc: "Test Timer Callback 1", + timerID: "test1-update-timer", + defaultInterval: 86400, + prefInterval: "test1.timer.interval", + contractID: "@mozilla.org/test2/timercallback;1", + method: "createInstance", + classID: Components.ID("512834f3-05bb-46be-84e0-81d881a140b7"), + notified: false +}, { + desc: "Test Timer Callback 2", + timerID: "test2-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + prefInterval: "test2.timer.interval", + contractID: "@mozilla.org/test2/timercallback;1", + method: "createInstance", + classID: Components.ID("c8ac5027-8d11-4471-9d7c-fd692501b437"), + notified: false +}, { + desc: "Test Timer Callback 3", + timerID: "test3-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + prefInterval: "test3.timer.interval", + contractID: "@mozilla.org/test3/timercallback;1", + method: "createInstance", + classID: Components.ID("6b0e79f3-4ab8-414c-8f14-dde10e185727"), + notified: false +}, { + desc: "Test Timer Callback 4", + timerID: "test4-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + prefInterval: "test4.timer.interval", + contractID: "@mozilla.org/test4/timercallback;1", + method: "createInstance", + classID: Components.ID("2f6b7b92-e40f-4874-bfbb-eeb2412c959d"), + notified: false +}, { + desc: "Test Timer Callback 5", + timerID: "test5-update-timer", + defaultInterval: 86400, + prefInterval: "test5.timer.interval", + contractID: "@mozilla.org/test5/timercallback;1", + method: "createInstance", + classID: Components.ID("8a95f611-b2ac-4c7e-8b73-9748c4839731"), + notified: false +}, { + desc: "Test Timer Callback 6", + timerID: "test6-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + prefInterval: "test6.timer.interval", + contractID: "@mozilla.org/test6/timercallback;1", + method: "createInstance", + classID: Components.ID("2d091020-e23c-11e2-a28f-0800200c9a66"), + notified: false +}, { + desc: "Test Timer Callback 7", + timerID: "test7-update-timer", + defaultInterval: 86400, + maxInterval: CONSUMER_TIMER_INTERVAL, + prefInterval: "test7.timer.interval", + contractID: "@mozilla.org/test7/timercallback;1", + method: "createInstance", + classID: Components.ID("8e8633ae-1d70-4a7a-8bea-6e1e6c5d7742"), + notified: false +}, { + desc: "Test Timer Callback 8", + timerID: "test8-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + contractID: "@mozilla.org/test8/timercallback;1", + classID: Components.ID("af878d4b-1d12-41f6-9a90-4e687367ecc1"), + notified: false, + lastUpdateTime: 0 +}, { + desc: "Test Timer Callback 9", + timerID: "test9-update-timer", + defaultInterval: CONSUMER_TIMER_INTERVAL, + contractID: "@mozilla.org/test9/timercallback;1", + classID: Components.ID("5136b201-d64c-4328-8cf1-1a63491cc117"), + notified: false, + lastUpdateTime: 0 +} ]; + +var gUTM; +var gNextFunc; + +XPCOMUtils.defineLazyServiceGetter(this, "gPref", + "@mozilla.org/preferences-service;1", + "nsIPrefBranch"); + +XPCOMUtils.defineLazyServiceGetter(this, "gCatMan", + "@mozilla.org/categorymanager;1", + "nsICategoryManager"); + +XPCOMUtils.defineLazyGetter(this, "gCompReg", function () { + return Cm.QueryInterface(Ci.nsIComponentRegistrar); +}); + +const gTest0TimerCallback = { + notify: function T0CB_notify(aTimer) { + // This can happen when another notification fails and this timer having + // time to fire so check other timers are successful. + do_throw("gTest0TimerCallback notify method should not have been called"); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest0Factory = { + createInstance: function T0F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest0TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest1TimerCallback = { + notify: function T1CB_notify(aTimer) { + // This can happen when another notification fails and this timer having + // time to fire so check other timers are successful. + do_throw("gTest1TimerCallback notify method should not have been called"); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimer]) +}; + +const gTest1Factory = { + createInstance: function T1F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest1TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest2TimerCallback = { + notify: function T2CB_notify(aTimer) { + // This can happen when another notification fails and this timer having + // time to fire so check other timers are successful. + do_throw("gTest2TimerCallback notify method should not have been called"); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest2Factory = { + createInstance: function T2F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest2TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest3TimerCallback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest3Factory = { + createInstance: function T3F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest3TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest4TimerCallback = { + notify: function T4CB_notify(aTimer) { + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[4].desc, true); + TESTS[4].notified = true; + finished_test0thru7(); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest4Factory = { + createInstance: function T4F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest4TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest5TimerCallback = { + notify: function T5CB_notify(aTimer) { + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[5].desc, true); + TESTS[5].notified = true; + finished_test0thru7(); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest5Factory = { + createInstance: function T5F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest5TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest6TimerCallback = { + notify: function T6CB_notify(aTimer) { + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[6].desc, true); + TESTS[6].notified = true; + finished_test0thru7(); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest6Factory = { + createInstance: function T6F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest6TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest7TimerCallback = { + notify: function T7CB_notify(aTimer) { + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[7].desc, true); + TESTS[7].notified = true; + finished_test0thru7(); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest7Factory = { + createInstance: function T7F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest7TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest8TimerCallback = { + notify: function T8CB_notify(aTimer) { + TESTS[8].notified = true; + TESTS[8].notifyTime = Date.now(); + do_execute_soon(function () { + check_test8thru9(gTest8TimerCallback); + }); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest8Factory = { + createInstance: function T8F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest8TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +const gTest9TimerCallback = { + notify: function T9CB_notify(aTimer) { + TESTS[9].notified = true; + TESTS[9].notifyTime = Date.now(); + do_execute_soon(function () { + check_test8thru9(gTest9TimerCallback); + }); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback]) +}; + +const gTest9Factory = { + createInstance: function T9F_createInstance(aOuter, aIID) { + if (aOuter == null) { + return gTest9TimerCallback.QueryInterface(aIID); + } + throw Cr.NS_ERROR_NO_AGGREGATION; + } +}; + +function run_test() { + do_test_pending(); + + // Set the timer to fire every second + gPref.setIntPref(PREF_APP_UPDATE_TIMERMINIMUMDELAY, MAIN_TIMER_INTERVAL / 1000); + gPref.setIntPref(PREF_APP_UPDATE_TIMERFIRSTINTERVAL, MAIN_TIMER_INTERVAL); + gPref.setBoolPref(PREF_APP_UPDATE_LOG_ALL, true); + + // Remove existing update timers to prevent them from being notified + let entries = gCatMan.enumerateCategory(CATEGORY_UPDATE_TIMER); + while (entries.hasMoreElements()) { + let entry = entries.getNext().QueryInterface(Ci.nsISupportsCString).data; + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, entry, false); + } + + gUTM = Cc["@mozilla.org/updates/timer-manager;1"]. + getService(Ci.nsIUpdateTimerManager). + QueryInterface(Ci.nsIObserver); + gUTM.observe(null, "utm-test-init", ""); + + do_execute_soon(run_test0thru7); +} + +function end_test() { + gUTM.observe(null, "xpcom-shutdown", ""); + do_test_finished(); +} + +function run_test0thru7() { + gNextFunc = check_test0thru7; + // bogus default interval + gCompReg.registerFactory(TESTS[0].classID, TESTS[0].desc, + TESTS[0].contractID, gTest0Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[0].desc, + [TESTS[0].contractID, TESTS[0].method, + TESTS[0].timerID, TESTS[0].prefInterval, + TESTS[0].defaultInterval].join(","), false, true); + + // doesn't implement nsITimerCallback + gCompReg.registerFactory(TESTS[1].classID, TESTS[1].desc, + TESTS[1].contractID, gTest1Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[1].desc, + [TESTS[1].contractID, TESTS[1].method, + TESTS[1].timerID, TESTS[1].prefInterval, + TESTS[1].defaultInterval].join(","), false, true); + + // has a last update time of now - 43200 which is half of its interval + let lastUpdateTime = Math.round(Date.now() / 1000) - 43200; + gPref.setIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[2].timerID, lastUpdateTime); + gCompReg.registerFactory(TESTS[2].classID, TESTS[2].desc, + TESTS[2].contractID, gTest2Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[2].desc, + [TESTS[2].contractID, TESTS[2].method, + TESTS[2].timerID, TESTS[2].prefInterval, + TESTS[2].defaultInterval].join(","), false, true); + + // doesn't have a notify method + gCompReg.registerFactory(TESTS[3].classID, TESTS[3].desc, + TESTS[3].contractID, gTest3Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[3].desc, + [TESTS[3].contractID, TESTS[3].method, + TESTS[3].timerID, TESTS[3].prefInterval, + TESTS[3].defaultInterval].join(","), false, true); + + // already has a last update time + gPref.setIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[4].timerID, 1); + gCompReg.registerFactory(TESTS[4].classID, TESTS[4].desc, + TESTS[4].contractID, gTest4Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[4].desc, + [TESTS[4].contractID, TESTS[4].method, + TESTS[4].timerID, TESTS[4].prefInterval, + TESTS[4].defaultInterval].join(","), false, true); + + // has an interval preference that overrides the default + gPref.setIntPref(TESTS[5].prefInterval, CONSUMER_TIMER_INTERVAL); + gCompReg.registerFactory(TESTS[5].classID, TESTS[5].desc, + TESTS[5].contractID, gTest5Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[5].desc, + [TESTS[5].contractID, TESTS[5].method, + TESTS[5].timerID, TESTS[5].prefInterval, + TESTS[5].defaultInterval].join(","), false, true); + + // has a next update time 24 hours from now + let nextUpdateTime = Math.round(Date.now() / 1000) + 86400; + gPref.setIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[6].timerID, nextUpdateTime); + gCompReg.registerFactory(TESTS[6].classID, TESTS[6].desc, + TESTS[6].contractID, gTest6Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[6].desc, + [TESTS[6].contractID, TESTS[6].method, + TESTS[6].timerID, TESTS[6].prefInterval, + TESTS[6].defaultInterval].join(","), false, true); + + // has a maximum interval set by the value of MAIN_TIMER_INTERVAL + gPref.setIntPref(TESTS[7].prefInterval, 86400); + gCompReg.registerFactory(TESTS[7].classID, TESTS[7].desc, + TESTS[7].contractID, gTest7Factory); + gCatMan.addCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[7].desc, + [TESTS[7].contractID, TESTS[7].method, + TESTS[7].timerID, TESTS[7].prefInterval, + TESTS[7].defaultInterval, + TESTS[7].maxInterval].join(","), false, true); +} + +function finished_test0thru7() { + if (TESTS[4].notified && TESTS[5].notified && TESTS[6].notified && TESTS[7].notified) { + do_execute_soon(gNextFunc); + } +} + +function check_test0thru7() { + Assert.ok(!TESTS[0].notified, + "a category registered timer didn't fire due to an invalid " + + "default interval"); + + Assert.ok(!TESTS[1].notified, + "a category registered timer didn't fire due to not implementing " + + "nsITimerCallback"); + + Assert.ok(!TESTS[2].notified, + "a category registered timer didn't fire due to the next update " + + "time being in the future"); + + Assert.ok(!TESTS[3].notified, + "a category registered timer didn't fire due to not having a " + + "notify method"); + + Assert.ok(TESTS[4].notified, + "a category registered timer has fired"); + + Assert.ok(TESTS[5].notified, + "a category registered timer fired that has an interval " + + "preference that overrides a default that wouldn't have fired yet"); + + Assert.ok(TESTS[6].notified, + "a category registered timer has fired due to the next update " + + "time being reset due to a future last update time"); + + Assert.ok(gPref.prefHasUserValue(PREF_BRANCH_LAST_UPDATE_TIME + + TESTS[4].timerID), + "first of two category registered timers last update time has " + + "a user value"); + Assert.ok(gPref.prefHasUserValue(PREF_BRANCH_LAST_UPDATE_TIME + + TESTS[5].timerID), + "second of two category registered timers last update time has " + + "a user value"); + + // Remove the category timers that should have failed + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[0].desc, true); + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[1].desc, true); + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[2].desc, true); + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, TESTS[3].desc, true); + let entries = gCatMan.enumerateCategory(CATEGORY_UPDATE_TIMER); + while (entries.hasMoreElements()) { + let entry = entries.getNext().QueryInterface(Ci.nsISupportsCString).data; + gCatMan.deleteCategoryEntry(CATEGORY_UPDATE_TIMER, entry, false); + } + + entries = gCatMan.enumerateCategory(CATEGORY_UPDATE_TIMER); + Assert.ok(!entries.hasMoreElements(), + "no " + CATEGORY_UPDATE_TIMER + " categories should still be " + + "registered"); + + do_execute_soon(run_test8thru9); +} + +function run_test8thru9() { + gPref.setIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[8].timerID, 1); + gCompReg.registerFactory(TESTS[8].classID, TESTS[8].desc, + TESTS[8].contractID, gTest8Factory); + gUTM.registerTimer(TESTS[8].timerID, gTest8TimerCallback, + TESTS[8].defaultInterval); + gPref.setIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[9].timerID, 1); + gCompReg.registerFactory(TESTS[9].classID, TESTS[9].desc, + TESTS[9].contractID, gTest9Factory); + gUTM.registerTimer(TESTS[9].timerID, gTest9TimerCallback, + TESTS[9].defaultInterval); +} + +function check_test8thru9(aTestTimerCallback) { + aTestTimerCallback.timesCalled = (aTestTimerCallback.timesCalled || 0) + 1; + if (aTestTimerCallback.timesCalled < 2) { + return; + } + + Assert.ok(TESTS[8].notified, + "first registerTimer registered timer should have fired"); + + Assert.ok(TESTS[9].notified, + "second registerTimer registered timer should have fired"); + + // Check that 'staggering' has happened: even though the two events wanted to fire at + // the same time, we waited a full MAIN_TIMER_INTERVAL between them. + // (to avoid sensitivity to random timing issues, we fudge by a factor of 0.5 here) + Assert.ok(Math.abs(TESTS[8].notifyTime - TESTS[9].notifyTime) >= + MAIN_TIMER_INTERVAL * 0.5, + "staggering between two timers that want to fire at the same " + + "time should have occured"); + + let time = gPref.getIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[8].timerID); + Assert.notEqual(time, 1, + "first registerTimer registered timer last update time " + + "should have been updated"); + + time = gPref.getIntPref(PREF_BRANCH_LAST_UPDATE_TIME + TESTS[9].timerID); + Assert.notEqual(time, 1, + "second registerTimer registered timer last update time " + + "should have been updated"); + + end_test(); +} diff --git a/toolkit/components/timermanager/tests/unit/xpcshell.ini b/toolkit/components/timermanager/tests/unit/xpcshell.ini new file mode 100644 index 000000000..89e192e94 --- /dev/null +++ b/toolkit/components/timermanager/tests/unit/xpcshell.ini @@ -0,0 +1,9 @@ +; 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/. + +[DEFAULT] +head = +tail = + +[consumerNotifications.js] |