diff options
Diffstat (limited to 'dom/settings/SettingsManager.js')
| -rw-r--r-- | dom/settings/SettingsManager.js | 506 |
1 files changed, 506 insertions, 0 deletions
diff --git a/dom/settings/SettingsManager.js b/dom/settings/SettingsManager.js new file mode 100644 index 000000000..a73e5f312 --- /dev/null +++ b/dom/settings/SettingsManager.js @@ -0,0 +1,506 @@ +/* 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/. */ + +"use strict"; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cu = Components.utils; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/DOMRequestHelper.jsm"); + +var DEBUG = false; +var VERBOSE = false; + +try { + DEBUG = + Services.prefs.getBoolPref("dom.mozSettings.SettingsManager.debug.enabled"); + VERBOSE = + Services.prefs.getBoolPref("dom.mozSettings.SettingsManager.verbose.enabled"); +} catch (ex) { } + +function debug(s) { + dump("-*- SettingsManager: " + s + "\n"); +} + +XPCOMUtils.defineLazyServiceGetter(Services, "DOMRequest", + "@mozilla.org/dom/dom-request-service;1", + "nsIDOMRequestService"); +XPCOMUtils.defineLazyServiceGetter(this, "cpmm", + "@mozilla.org/childprocessmessagemanager;1", + "nsIMessageSender"); +XPCOMUtils.defineLazyServiceGetter(this, "mrm", + "@mozilla.org/memory-reporter-manager;1", + "nsIMemoryReporterManager"); +XPCOMUtils.defineLazyServiceGetter(this, "uuidgen", + "@mozilla.org/uuid-generator;1", + "nsIUUIDGenerator"); + +const kObserverSoftLimit = 10; + +/** + * In order to make SettingsManager work with Privileged Apps, we need the lock + * to be OOP. However, the lock state needs to be managed on the child process, + * while the IDB functions now happen on the parent process so we don't have to + * expose IDB permissions at the child process level. We use the + * DOMRequestHelper mechanism to deal with DOMRequests/promises across the + * processes. + * + * However, due to the nature of the IDBTransaction lifetime, we need to relay + * to the parent when to finalize the transaction once the child is done with the + * lock. We keep a list of all open requests for a lock, and once the lock + * reaches the end of its receiveMessage function with no more queued requests, + * we consider it dead. At that point, we send a message to the parent to notify + * it to finalize the transaction. + */ + +function SettingsLock(aSettingsManager) { + if (VERBOSE) debug("settings lock init"); + this._open = true; + this._settingsManager = aSettingsManager; + this._id = uuidgen.generateUUID().toString(); + + // DOMRequestIpcHelper.initHelper sets this._window + this.initDOMRequestHelper(this._settingsManager._window, ["Settings:Get:OK", "Settings:Get:KO", + "Settings:Clear:OK", "Settings:Clear:KO", + "Settings:Set:OK", "Settings:Set:KO", + "Settings:Finalize:OK", "Settings:Finalize:KO"]); + let createLockPayload = { + lockID: this._id, + isServiceLock: false, + windowID: this._settingsManager.innerWindowID, + lockStack: (new Error).stack + }; + this.sendMessage("Settings:CreateLock", createLockPayload); + Services.tm.currentThread.dispatch(this._closeHelper.bind(this), Ci.nsIThread.DISPATCH_NORMAL); + + // We only want to file closeHelper once per set of receiveMessage calls. + this._closeCalled = true; +} + +SettingsLock.prototype = { + __proto__: DOMRequestIpcHelper.prototype, + set onsettingstransactionsuccess(aHandler) { + this.__DOM_IMPL__.setEventHandler("onsettingstransactionsuccess", aHandler); + }, + + get onsettingstransactionsuccess() { + return this.__DOM_IMPL__.getEventHandler("onsettingstransactionsuccess"); + }, + + set onsettingstransactionfailure(aHandler) { + this.__DOM_IMPL__.setEventHandler("onsettingstransactionfailure", aHandler); + }, + + get onsettingstransactionfailure() { + return this.__DOM_IMPL__.getEventHandler("onsettingstransactionfailure"); + }, + + get closed() { + return !this._open; + }, + + _closeHelper: function() { + if (VERBOSE) debug("closing lock " + this._id); + this._open = false; + this._closeCalled = false; + if (!this._requests || Object.keys(this._requests).length == 0) { + if (VERBOSE) debug("Requests exhausted, finalizing " + this._id); + this._settingsManager.unregisterLock(this._id); + this.sendMessage("Settings:Finalize", {lockID: this._id}); + } else { + if (VERBOSE) debug("Requests left: " + Object.keys(this._requests).length); + this.sendMessage("Settings:Run", {lockID: this._id}); + } + }, + + + _wrap: function _wrap(obj) { + return Cu.cloneInto(obj, this._settingsManager._window); + }, + + sendMessage: function(aMessageName, aData) { + // sendMessage can be called after our window has died, or get + // queued to run later in a thread via _closeHelper, but the + // SettingsManager may have died in between the time it was + // scheduled and the time it runs. Make sure our window is valid + // before sending, otherwise just ignore. + if (!this._settingsManager._window) { + Cu.reportError( + "SettingsManager window died, cannot run settings transaction." + + " SettingsMessage: " + aMessageName + + " SettingsData: " + JSON.stringify(aData)); + return; + } + cpmm.sendAsyncMessage(aMessageName, + aData, + undefined, + this._settingsManager._window.document.nodePrincipal); + }, + + receiveMessage: function(aMessage) { + let msg = aMessage.data; + + // SettingsRequestManager broadcasts changes to all locks in the child. If + // our lock isn't being addressed, just return. + if (msg.lockID != this._id) { + return; + } + if (VERBOSE) debug("receiveMessage (" + this._id + "): " + aMessage.name); + + // Finalizing a transaction does not return a request ID since we are + // supposed to fire callbacks. + // + // We also destroy the DOMRequestHelper after we've received the + // finalize message. At this point, we will be guarenteed no more + // request returns are coming from the SettingsRequestManager. + + if (!msg.requestID) { + let event; + switch (aMessage.name) { + case "Settings:Finalize:OK": + if (VERBOSE) debug("Lock finalize ok: " + this._id); + event = new this._window.MozSettingsTransactionEvent("settingstransactionsuccess", {}); + this.__DOM_IMPL__.dispatchEvent(event); + this.destroyDOMRequestHelper(); + break; + case "Settings:Finalize:KO": + if (DEBUG) debug("Lock finalize failed: " + this._id); + event = new this._window.MozSettingsTransactionEvent("settingstransactionfailure", { + error: msg.errorMsg + }); + this.__DOM_IMPL__.dispatchEvent(event); + this.destroyDOMRequestHelper(); + break; + default: + if (DEBUG) debug("Message type " + aMessage.name + " is missing a requestID"); + } + return; + } + + + let req = this.getRequest(msg.requestID); + if (!req) { + if (DEBUG) debug("Matching request not found."); + return; + } + this.removeRequest(msg.requestID); + // DOMRequest callbacks called from here can die due to having + // things like marionetteScriptFinished in them. Make sure we file + // our call to run/finalize BEFORE opening the lock and fulfilling + // DOMRequests. + if (!this._closeCalled) { + // We only want to file closeHelper once per set of receiveMessage calls. + Services.tm.currentThread.dispatch(this._closeHelper.bind(this), Ci.nsIThread.DISPATCH_NORMAL); + this._closeCalled = true; + } + if (VERBOSE) debug("receiveMessage: " + aMessage.name); + switch (aMessage.name) { + case "Settings:Get:OK": + for (let i in msg.settings) { + msg.settings[i] = this._wrap(msg.settings[i]); + } + this._open = true; + Services.DOMRequest.fireSuccess(req.request, this._wrap(msg.settings)); + this._open = false; + break; + case "Settings:Set:OK": + case "Settings:Clear:OK": + this._open = true; + Services.DOMRequest.fireSuccess(req.request, 0); + this._open = false; + break; + case "Settings:Get:KO": + case "Settings:Set:KO": + case "Settings:Clear:KO": + if (DEBUG) debug("error:" + msg.errorMsg); + Services.DOMRequest.fireError(req.request, msg.errorMsg); + break; + default: + if (DEBUG) debug("Wrong message: " + aMessage.name); + } + }, + + get: function get(aName) { + if (VERBOSE) debug("get (" + this._id + "): " + aName); + if (!this._open) { + dump("Settings lock not open!\n"); + throw Components.results.NS_ERROR_ABORT; + } + let req = this.createRequest(); + let reqID = this.getRequestId({request: req}); + this.sendMessage("Settings:Get", {requestID: reqID, + lockID: this._id, + name: aName}); + return req; + }, + + set: function set(aSettings) { + if (VERBOSE) debug("send: " + JSON.stringify(aSettings)); + if (!this._open) { + throw "Settings lock not open"; + } + let req = this.createRequest(); + let reqID = this.getRequestId({request: req}); + this.sendMessage("Settings:Set", {requestID: reqID, + lockID: this._id, + settings: aSettings}); + return req; + }, + + clear: function clear() { + if (VERBOSE) debug("clear"); + if (!this._open) { + throw "Settings lock not open"; + } + let req = this.createRequest(); + let reqID = this.getRequestId({request: req}); + this.sendMessage("Settings:Clear", {requestID: reqID, + lockID: this._id}); + return req; + }, + + classID: Components.ID("{60c9357c-3ae0-4222-8f55-da01428470d5}"), + contractID: "@mozilla.org/settingsLock;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, + Ci.nsIObserver, + Ci.nsISupportsWeakReference]) +}; + +function SettingsManager() { + this._callbacks = null; + this._isRegistered = false; + this._locks = []; + this._createdLocks = 0; + this._unregisteredLocks = 0; +} + +SettingsManager.prototype = { + _wrap: function _wrap(obj) { + return Cu.cloneInto(obj, this._window); + }, + + set onsettingchange(aHandler) { + this.__DOM_IMPL__.setEventHandler("onsettingchange", aHandler); + this.checkMessageRegistration(); + }, + + get onsettingchange() { + return this.__DOM_IMPL__.getEventHandler("onsettingchange"); + }, + + createLock: function() { + let lock = new SettingsLock(this); + if (VERBOSE) debug("creating lock " + lock._id); + this._locks.push(lock._id); + this._createdLocks++; + return lock; + }, + + unregisterLock: function(aLockID) { + let lock_index = this._locks.indexOf(aLockID); + if (lock_index != -1) { + if (VERBOSE) debug("Unregistering lock " + aLockID); + this._locks.splice(lock_index, 1); + this._unregisteredLocks++; + } + }, + + receiveMessage: function(aMessage) { + if (VERBOSE) debug("Settings::receiveMessage: " + aMessage.name); + let msg = aMessage.json; + + switch (aMessage.name) { + case "Settings:Change:Return:OK": + if (VERBOSE) debug('data:' + msg.key + ':' + msg.value + '\n'); + + let event = new this._window.MozSettingsEvent("settingchange", this._wrap({ + settingName: msg.key, + settingValue: msg.value + })); + this.__DOM_IMPL__.dispatchEvent(event); + + if (this._callbacks && this._callbacks[msg.key]) { + if (VERBOSE) debug("observe callback called! " + msg.key + " " + this._callbacks[msg.key].length); + this._callbacks[msg.key].forEach(function(cb) { + cb(this._wrap({settingName: msg.key, settingValue: msg.value})); + }.bind(this)); + } else { + if (VERBOSE) debug("no observers stored!"); + } + break; + default: + if (DEBUG) debug("Wrong message: " + aMessage.name); + } + }, + + // If we have either observer callbacks or an event handler, + // register for messages from the main thread. Otherwise, if no one + // is listening, unregister to reduce parent load. + checkMessageRegistration: function checkRegistration() { + let handler = this.__DOM_IMPL__.getEventHandler("onsettingchange"); + if (!this._isRegistered) { + if (VERBOSE) debug("Registering for messages"); + cpmm.sendAsyncMessage("Settings:RegisterForMessages", + undefined, + undefined, + this._window.document.nodePrincipal); + this._isRegistered = true; + } else { + if ((!this._callbacks || Object.keys(this._callbacks).length == 0) && + !handler) { + if (VERBOSE) debug("Unregistering for messages"); + cpmm.sendAsyncMessage("Settings:UnregisterForMessages", + undefined, + undefined, + this._window.document.nodePrincipal); + this._isRegistered = false; + this._callbacks = null; + } + } + }, + + addObserver: function addObserver(aName, aCallback) { + if (VERBOSE) debug("addObserver " + aName); + + if (!this._callbacks) { + this._callbacks = {}; + } + + if (!this._callbacks[aName]) { + this._callbacks[aName] = [aCallback]; + } else { + this._callbacks[aName].push(aCallback); + } + + let length = this._callbacks[aName].length; + if (length >= kObserverSoftLimit) { + debug("WARNING: MORE THAN " + kObserverSoftLimit + " OBSERVERS FOR " + + aName + ": " + length + " FROM" + (new Error).stack); +#ifdef DEBUG + debug("JS STOPS EXECUTING AT THIS POINT IN DEBUG BUILDS!"); + throw Components.results.NS_ERROR_ABORT; +#endif + } + + this.checkMessageRegistration(); + }, + + removeObserver: function removeObserver(aName, aCallback) { + if (VERBOSE) debug("deleteObserver " + aName); + if (this._callbacks && this._callbacks[aName]) { + let index = this._callbacks[aName].indexOf(aCallback); + if (index != -1) { + this._callbacks[aName].splice(index, 1); + if (this._callbacks[aName].length == 0) { + delete this._callbacks[aName]; + } + } else { + if (VERBOSE) debug("Callback not found for: " + aName); + } + } else { + if (VERBOSE) debug("No observers stored for " + aName); + } + this.checkMessageRegistration(); + }, + + init: function(aWindow) { + if (VERBOSE) debug("SettingsManager init"); + mrm.registerStrongReporter(this); + cpmm.addMessageListener("Settings:Change:Return:OK", this); + Services.obs.addObserver(this, "inner-window-destroyed", false); + let util = aWindow.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils); + this.innerWindowID = util.currentInnerWindowID; + this._window = aWindow; + }, + + observe: function(aSubject, aTopic, aData) { + if (VERBOSE) debug("Topic: " + aTopic); + if (aTopic === "inner-window-destroyed") { + let wId = aSubject.QueryInterface(Ci.nsISupportsPRUint64).data; + if (wId === this.innerWindowID) { + if (DEBUG) debug("Received: inner-window-destroyed for valid innerWindowID=" + wId + ", cleanup."); + this.cleanup(); + } + } + }, + + collectReports: function(aCallback, aData, aAnonymize) { + for (let topic in this._callbacks) { + let length = this._callbacks[topic].length; + if (length == 0) { + continue; + } + + let path; + if (length < kObserverSoftLimit) { + path = "settings-observers"; + } else { + path = "settings-observers-suspect/referent(topic=" + + (aAnonymize ? "<anonymized>" : topic) + ")"; + } + + aCallback.callback("", path, + Ci.nsIMemoryReporter.KIND_OTHER, + Ci.nsIMemoryReporter.UNITS_COUNT, + length, + "The number of settings observers for this topic.", + aData); + } + + aCallback.callback("", + "settings-locks/alive", + Ci.nsIMemoryReporter.KIND_OTHER, + Ci.nsIMemoryReporter.UNITS_COUNT, + this._locks.length, + "The number of locks that are currently alives.", + aData); + + aCallback.callback("", + "settings-locks/created", + Ci.nsIMemoryReporter.KIND_OTHER, + Ci.nsIMemoryReporter.UNITS_COUNT, + this._createdLocks, + "The number of locks that were created.", + aData); + + aCallback.callback("", + "settings-locks/deleted", + Ci.nsIMemoryReporter.KIND_OTHER, + Ci.nsIMemoryReporter.UNITS_COUNT, + this._unregisteredLocks, + "The number of locks that were deleted.", + aData); + }, + + cleanup: function() { + Services.obs.removeObserver(this, "inner-window-destroyed"); + // At this point, the window is dying, so there's nothing left + // that we could do with our lock. Go ahead and run finalize on + // it to make sure changes are commited. + for (let i = 0; i < this._locks.length; ++i) { + if (DEBUG) debug("Lock alive at destroy, finalizing: " + this._locks[i]); + // Due to bug 1105511 we should be able to send this without + // cached principals. However, this is scary because any iframe + // in the process could run this? + cpmm.sendAsyncMessage("Settings:Finalize", + {lockID: this._locks[i]}); + } + cpmm.removeMessageListener("Settings:Change:Return:OK", this); + mrm.unregisterStrongReporter(this); + this.innerWindowID = null; + this._window = null; + }, + + classID: Components.ID("{c40b1c70-00fb-11e2-a21f-0800200c9a66}"), + contractID: "@mozilla.org/settingsManager;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, + Ci.nsIDOMGlobalPropertyInitializer, + Ci.nsIObserver, + Ci.nsIMemoryReporter]), +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SettingsManager, SettingsLock]); |